package com.iris.live.services.services.impl;

import com.google.common.base.Strings;
import com.google.common.collect.Maps;
import com.iris.live.services.common.DateFormatUtils;
import com.iris.live.services.common.JsonObjectUtils;
import com.iris.live.services.common.LshMsgUtils;
import com.iris.live.services.common.StringUtils;
import com.iris.live.services.common.reconsitution.MessageContext;
import com.iris.live.services.data.models.*;
import com.iris.live.services.data.repositories.*;
import com.iris.live.services.models.PageData;
import com.iris.live.services.models.ResultData;
import com.iris.live.services.services.MessageService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

import static com.iris.live.services.common.DateFormatUtils.getFormatDate;

/**
 * Created by Huang Yongping on 2016/9/17.
 */

@Service
public class MessageServiceImpl implements MessageService {
    private static Logger logger = LoggerFactory.getLogger(MessageServiceImpl.class);

    @Autowired
    private MessageRepository messageRepository;

    @Autowired
    private Lsh消息Repository lsh消息Repository;

    @Autowired
    private Lsh待办事项Repository lsh待办事项Repository;

    @Autowired
    private Lsh活动表Repository lsh活动表Repository;

    @Autowired
    private Lsh市场设置Repository lsh市场设置Repository;

    @Autowired
    private Lsh导入名单联系表Repository lsh导入名单联系表Repository;

    @Autowired
    private Lsh导入名单联系附属Repository lsh导入名单联系附属Repository;

    @Autowired
    private Lsh导入名单Repository lsh导入名单Repository;

    @Autowired
    private 顾客记录汇总Repository repository顾客记录汇总;

    @Autowired
    private 顾客订单记录Repository repository顾客订单记录;

    @Autowired
    private 用户Repository repository用户;

    @Autowired
    private Lsh车型Repository lsh车型Repository;

    @Autowired
    private Lsh活动发起设置Repository lsh活动发起设置Repository;

    @Autowired
    private 顾客进店记录表Repository repository顾客进店记录表;

    @Autowired
    private InroomActRepository inroomActRepository;

    @Autowired
    private 报价单表Repository repository报价单表;

    @Autowired
    private 报价交车表Repository repository报价交车;

    /**
     * 校验手机号格式
     *
     * @param str
     * @return
     */
    public static boolean isMobile(String str) {
        Pattern p = null;
        Matcher m = null;
        boolean b = false;
        p = Pattern.compile("^[0-9]{11}"); // 验证手机号
        m = p.matcher(str);
        b = m.matches();
        return b;
    }

    public static boolean isValidDate(String str) {
        boolean convertSuccess = true;
        // 指定日期格式为四位年/两位月份/两位日期，注意yyyy/MM/dd区分大小写；
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            // 设置lenient为false. 否则SimpleDateFormat会比较宽松地验证日期，比如2007/02/29会被接受，并转换成2007/03/01
            format.setLenient(false);
            format.parse(str);
        } catch (Exception e) {
            // e.printStackTrace();
            // 如果throw java.text.ParseException或者NullPointerException，就说明格式不对
            convertSuccess = false;
        }
        return convertSuccess;
    }

    /**
     * 根据许可和附属编号，获取最近一条预约信息
     */
    @Override
    public List getLatestAppointmentMsg(GetAppointmentMsgRequest request) {
        return messageRepository.getLatestAppointmentMsg(request.subNum, request.permit);
    }

    public ResultData getClientInfoByTel(MessageService.SaveActivityInviteRequest req, String permit, String username) {
        // 这是伪需求 ， 明显 就是 闲的没事搞，故意整人整出来的 需求
        String msg = null;
        String flag = "";
        ResultData rd = new ResultData();
        PageData pd = new PageData();
        try {
            pd = messageRepository.getClientInfoByTel(req, permit);
            msg = "查询成功";
            flag = "true";
        } catch (Exception e) {
            logger.warn(String.format("前台根据顾客电话查询顾客信息失败，许可=%s，电话=%s", permit, req.电话号码), e);
            msg = "查询失败";
            flag = "false";
        }

        rd.setMessage(msg);
        rd.setResult(flag);
        rd.setPageData(pd);
        return rd;
    }

    /**
     * 根据id和许可，删除预约信息
     */
    @Override
    public boolean delAppointmentMsgById(GetAppointmentMsgRequest request) {
        try {
            lsh待办事项Repository.delAppointmentMsgById(request.AppointmentId, request.permit);
        } catch (Exception e) {
            logger.error("数据删除异常。", e);

            return false;
        }
        return true;
    }

    /**
     * 根据消息附属ID,许可 查询LSH消息
     */
    @Override
    public List getLshMessageByIdAndPermit(GetLshMessageRequest request) {
        return messageRepository.getLshMessageByIdAndPermit(request.subStringInfo, request.permit);
    }

    /**
     * 保存LSH消息
     */
    @Override
    public Lsh消息Model saveLshMessageModel(Lsh消息Model model) {
        if (model.get消息分类() == null) {
            model.set消息分类("线索");
        }
        return lsh消息Repository.save(model);
    }

    /**
     * 删除LSH消息
     */
    @Override
    public boolean delLshMessageById(Integer id) {
        try {
            Lsh消息Model model = lsh消息Repository.findOne(id);
            if (model != null) {
                lsh消息Repository.delete(id);
            }
        } catch (Exception e) {
            logger.error("数据删除异常。", e);

            return false;
        }
        return true;
    }

    /**
     * 新增预约消息
     */
    @Override
    public Lsh待办事项Model saveAppointmentMsg(Lsh待办事项Model model) {
        model.set待办分类("预约接待");
        model.set附属编号类型("线索");
        model.set是否删除("否");
        Timestamp ts = Timestamp.valueOf(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        model.set更新时间(ts);
        return lsh待办事项Repository.save(model);
    }

    /**
     * 判断是否存在活动
     */
    @Override
    public boolean isExistActivity(GetLshActivityRequest request) {
        int count = lsh活动表Repository.isExistActivity(request.activityCode, request.permit);
        return count > 0 ? true : false;
    }

    /**
     * 获取市场活动编号
     */
    @Override
    public List<Lsh市场设置Model> getMarketId(Lsh市场设置Model req) {
        List<Lsh市场设置Model> list = lsh市场设置Repository.getMarketId(req.get许可(), req.get渠道(),
                req.get来源分类(), req.get来源());
        return list;
    }

    /**
     * 保存关联活动
     */
    @Override
    @Transactional
    public boolean saveLinkedActivity(GetLshActivityRequest request) {
        try {
            Lsh导入名单联系表Model model导入名单联系表 = lsh导入名单联系表Repository.findByImportIdAndPermit(request.importId, request.permit);
            //删除lsh导入名单联系附属
            Integer recordId = null;
            if (model导入名单联系表 == null) {
                Lsh导入名单联系表Model m = new Lsh导入名单联系表Model();
                m.set更新账号(request.所属CDO);
                m.set更新时间(DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date()));
                m.set导入编号(request.importId);
                m.set许可(request.permit);
                Lsh导入名单联系表Model newRecord = lsh导入名单联系表Repository.save(m);
                recordId = newRecord.get联系记录编号();
            } else {
                recordId = model导入名单联系表.get联系记录编号();
            }
            List<Lsh导入名单联系附属Model> list导入名单联系附属 = lsh导入名单联系附属Repository.findBy联系记录编号(recordId);
            if (list导入名单联系附属.size() > 0) {
                lsh导入名单联系附属Repository.delete(list导入名单联系附属);
            }

            // 插入lsh导入名单联系附属
            if (request.activityCodeList != null) {
                String[] arr = AfterMarketServiceImpl.getStringArr(request.activityCodeList);
                for (int i = 0; i < arr.length; i++) {
                    Lsh导入名单联系附属Model m = new Lsh导入名单联系附属Model();
                    if (model导入名单联系表 == null) {
                        m.set联系记录编号(recordId);
                    } else {
                        m.set联系记录编号(model导入名单联系表.get联系记录编号());
                    }
                    m.set活动编号(Integer.valueOf(arr[i]));
                    Lsh导入名单联系附属Model newRecord = lsh导入名单联系附属Repository.save(m);
                }
            }
            return true;
        } catch (Exception e) {
            logger.error("数据保存异常。", e);
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return false;
        }
    }

    /**
     * 判断名单是否为有效线索
     */
    @Override
    public ResultData isAvailableClue(GetLshActivityRequest request) {
        Calendar c = Calendar.getInstance();
        c.add(Calendar.MONTH, -2);
        Date endDate = getFormatDate("yyyy-MM-dd", new Date());
        Date startDate = getFormatDate("yyyy-MM-01", c.getTime());
        ResultData rd = new ResultData();
        String msg = null;
        String flag = "false";
        //根据 许可 电话号码 查询 顾客记录汇总
        if (!Strings.isNullOrEmpty(request.phone) && !Strings.isNullOrEmpty(request.permit)) {
            顾客记录汇总Model item = repository顾客记录汇总.findCusByPhoneAndPermit(request.phone, request.permit);
            logger.info("电话号码：" + request.phone + ",顾客记录汇总是否为空 =" + (item == null));
            if (item != null) {
                if (Strings.isNullOrEmpty(item.get顾客状态())) {
                    flag = "true";
                    msg = "该线索已存在";
                } else {
                    if (((item.get顾客状态()).equals("战败")) || ((item.get顾客状态()).equals("已订单")) || ((item.get顾客状态()).equals("已交车"))) {
                        List<Lsh导入名单Model> list = lsh导入名单Repository.isAvailableClue(request.phone, request.permit, startDate, endDate);
                        logger.info("Lsh导入名单Model大小:" + list.size());
                        if (((item.get顾客状态()).equals("已交车"))) {
                            // 如果顾客状态  = 已交车，获取交车日期
                            String carDate1 = getSoleCarDateByClientNoAndIs(item);
                            logger.info("carDate1=" + carDate1);
                            if (list != null && list.size() > 0) {
                                if (carDate1.equals("false") || carDate1.equals("null")) {
                                    //如果 交车日期 不存在 或者无法  查到 那么 交车日期< 线索创建日期
                                    flag = "true";
                                    msg = "该线索已存在";
//                                } else if (carDate1.equals("null")) {
//                                    flag = "true";
//                                    msg = "该线索已存在";
                                } else {
                                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                                    Lsh导入名单Model comparemodel = list.get(0);
                                    try {
                                        String carDate2 = sdf.format(comparemodel.get线索创建日期());
                                        logger.info("carDate2=" + carDate2);
                                        int result = carDate1.compareTo(carDate2);
                                        logger.info("result=" + result);
                                        if (result < 0) {
                                            flag = "true";
                                            msg = "该线索已存在";
                                        } else {
                                            flag = "false";
                                            msg = "正常";
                                        }

                                    } catch (Exception e) {
                                        logger.error("cdo线索判断处，日期转化出错", e);
                                    }
                                }

                            } else {
                                flag = "false";
                                msg = "正常";
                            }

                        } else {
                            // 如果顾客状态 ! = 已交车
                            if (list != null && list.size() > 0) {
                                msg = "该线索已存在";
                                flag = "true";
                            } else {
                                flag = "false";
                                msg = "正常";
                            }
                        }
                    } else {
                        // 如果顾客状态 NOT IN （已订单、已交车、战败）
                        msg = "该线索已存在";
                        flag = "true";
                    }
                }

            } else {
                //  如果顾客汇总无记录
                List<Lsh导入名单Model> lists = lsh导入名单Repository.isAvailableClue(request.phone, request.permit, startDate, endDate);
                logger.info("lists.size()=" + lists.size());
                if (lists != null && lists.size() > 0) {
                    msg = "正常";
                    flag = "true";
                } else {
                    msg = "正常";
                    flag = "false";
                }

            }
        }
        rd.setResult(flag);
        rd.setMessage(msg);
        return rd;
    }

    // 根据 顾客编号 查出 报价单表 中的 初始报价编号---对应的 max的 报价编号+ 是否还原点 为 是---对应的 交车
    private String getSoleCarDateByClientNoAndIs(顾客记录汇总Model req) {
        //、、、、、、
        String restr = null;
        List<报价单表Model> items = repository报价单表.findBy顾客编号LimitOne(req.get顾客编号());
        List<报价单表Model> modelList = new ArrayList<>();
        if (items != null) {
            报价单表Model basemodel = items.get(0);
            modelList = repository报价单表.getListByInitQuoteNumberAnd是否还原点(basemodel.get初始报价单号());
            if (modelList != null && modelList.size() > 0) {
                报价单表Model modelitem = modelList.get(0);
                if (modelitem != null) {
                    ///////////魑
                    if (modelitem.get交车() != null) {
                        报价交车表Model resultmodel = repository报价交车.findOne(modelitem.get交车());
                        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                        if (resultmodel.get交车日期() != null) {
                            restr = sdf.format(resultmodel.get交车日期());

                        } else {
                            restr = "null";
                        }

                    } else {
                        restr = "false";
                    }

                } else {
                    restr = "false";
                }
            } else {
                restr = "false";
            }
        } else {
            restr = "false";
        }
        return restr;
    }

    /**
     * 获取今日跟进顾客记录
     */
    @Override
    public List getFollowingCustomer(GetLshActivityRequest request) {
        return messageRepository.getFollowingCustomer(request.permit, request.所属CDO);
    }

    /**
     * 保存导入名单(多条)
     */
    @Override
    @Transactional
    public Map saveImportRecords(List<GetLsh导入名单Request> modelList) {
        Map<String, Object> map = new HashMap<String, Object>();
        List succList = new ArrayList();//保存成功的记录电话
        List failList = new ArrayList();//保存失败的记录电话
        for (int m = 0; m < modelList.size(); m++) {
            Map errorMap = new HashMap();
            Lsh导入名单Model entity = new Lsh导入名单Model();
            boolean isReBuy = false;
            GetLsh导入名单Request model = modelList.get(m);
            //0. 根据销售顾问的名字和许可，查询出销售顾问的账号(email)

            String email = null;
            if (model.预约销售顾问 != null) {
                用户Model model用户 = repository用户.findUserByPermitAnd人员姓名(model.许可, model.预约销售顾问);
                if (model用户 != null) {
                    email = model用户.get用户名();
                } else {
                    String errorUser = "用户列表没有找到此销售顾问，销售顾问：" + model.预约销售顾问 + ",许可:" + model.许可 + ",顾客电话：" + model.电话号码;
                    errorMap.put("respMsg", errorUser);
                    errorMap.put("错误信息", model.预约销售顾问 + "不是销售顾问");
                    errorMap.put("电话", model.电话号码);
                    logger.error(errorUser);
                    failList.add(errorMap);
                    continue;
                }
            }

            //1.判断此名单是否为有效线索
            Calendar c = Calendar.getInstance();
            c.add(Calendar.MONTH, -2);
            Date endDate = getFormatDate("yyyy-MM-dd", new Date());
            Date startDate = getFormatDate("yyyy-MM-01", c.getTime());
            List<Lsh导入名单Model> lsh导入名单list = lsh导入名单Repository.isAvailableClue(model.电话号码, model.许可, startDate, endDate);

            //2.判断此名单是否是再购
            if ("再购".equals(model.渠道)) {
                //2.1根据名单电话号码和许可查询顾客记录汇总，获得顾客编号
                顾客记录汇总Model model顾客记录汇总 = repository顾客记录汇总.findCusByPhoneAndPermit(model.电话号码, model.许可);
                if (model顾客记录汇总 == null) {
                    //保存跳过的记录（当做失败）
                    String errorCusRecord = "顾客记录汇总没有此电话的顾客，顾客电话：" + model.电话号码 + ",许可:" + model.许可;
                    errorMap.put("respMsg", errorCusRecord);
                    logger.error(errorCusRecord);
                    errorMap.put("错误信息", "不是再购");
                    errorMap.put("电话", model.电话号码);
                    failList.add(errorMap);
                    continue;
                }
                //2.2查询顾客订单记录
                List<顾客订单记录Model> 顾客订单记录List = repository顾客订单记录.findOrderRecordByCusIdAndPermit(model顾客记录汇总.get顾客编号(), model.许可);
                if (顾客订单记录List.size() == 0) {
                    //保存跳过的记录（当做失败）
                    String errorOrderRecord = "顾客订单记录没有此顾客的订单信息，顾客编号：" + model顾客记录汇总.get顾客编号() + ",顾客电话：" + model.电话号码 + ",许可：" + model.许可;
                    errorMap.put("respMsg", errorOrderRecord);
                    logger.error(errorOrderRecord);
                    errorMap.put("错误信息", "不是再购");
                    errorMap.put("电话", model.电话号码);
                    failList.add(errorMap);
                    continue;
                }
                if (顾客订单记录List.size() > 0) {
                    for (int i = 0; i < 顾客订单记录List.size(); i++) {
                        if ("已交车".equals(顾客订单记录List.get(i).get状态())) {
                            //有已交车，再购,不跳过
                            //没有已交车，跳过
                            isReBuy = true;
                            break;
                        }
                    }
                }
                //没有已交车，跳过
                if (isReBuy == false) {
                    //保存跳过的记录（当做失败）
                    String errorIsCar = "此顾客没有已交车记录，顾客编号" + model顾客记录汇总.get顾客编号()
                            + ",顾客电话：" + model.电话号码 + ",许可：" + model.许可;
                    errorMap.put("respMsg", errorIsCar);
                    logger.error(errorIsCar);
                    errorMap.put("错误信息", "不是再购");
                    errorMap.put("电话", model.电话号码);
                    failList.add(errorMap);
                    continue;
                }
            }
            if ("推荐".equals(model.渠道)) {
                //查询顾客记录汇总,判断是否是推荐
                顾客记录汇总Model model推荐顾客记录汇总 = repository顾客记录汇总.findCusByPhoneAndPermit(model.phone推荐人, model.许可);
                if (model推荐顾客记录汇总 == null) {
                    //数据为空，不是推荐, 跳过此数据
                    //保存跳过的记录（当做失败）
                    String error推荐 = "推荐顾客记录汇总没有此推荐人,推荐人电话:" + model.phone推荐人 + ",许可：" + model.许可 + ",顾客电话：" + model.电话号码;
                    errorMap.put("respMsg", error推荐);
                    logger.error(error推荐);
                    errorMap.put("错误信息", model.phone推荐人 + "不是推荐人");
                    errorMap.put("电话", model.电话号码);
                    failList.add(errorMap);
                    continue;
                }
            }
            if ("主动集客".equals(model.渠道)) {
                // 如果意向车型和意向级别其中有一个为空、并且销售顾问不为空的话，不导入这条（主动集客）
                if ((StringUtils.isNullOrBlank(model.车型编号) || StringUtils.isNullOrBlank(model.客户级别)) && !StringUtils.isNullOrBlank(model.预约销售顾问)) {
                    logger.error("主动集客线索，缺少意向车型或者客户级别，不能分配销售顾问！顾客电话：{}，许可：{}",model.电话号码,model.许可);
                    errorMap.put("错误信息", "主动集客线索，缺少意向车型或者客户级别，不能分配销售顾问");
                    errorMap.put("电话", model.电话号码);
                    failList.add(errorMap);
                    continue;
                }
                entity.set导入状态(1);
                Lsh活动表Model model活动表 = lsh活动表Repository.getLsh活动表By活动代码And许可(model.活动代码, model.许可);
                //如果没有数据，跳过
                if (model活动表 == null) {
                    String error活动 = "活动表没有此活动信息，活动代码：" + model.活动代码 + ",许可:" + model.许可 + ",顾客电话：" + model.电话号码;
                    errorMap.put("respMsg", error活动);
                    logger.error(error活动);
                    errorMap.put("错误信息", "没有活动:" + model.活动代码);
                    errorMap.put("电话", model.电话号码);
                    failList.add(errorMap);
                    continue;
                } else {
                    //如果线索创建日期不在活动内,跳过
                    Date creatDate = model.线索创建日期;
                    if (model活动表.get开始日期().after(creatDate) || creatDate.after(model活动表.get结束日期())) {
                        errorMap.put("错误信息", "线索创建日期不在活动内");
                        errorMap.put("电话", model.电话号码);
                        failList.add(errorMap);
                        continue;
                    }
                    entity.set活动编号(model活动表.get活动编号());
                    //插入是否线索
                    List<Lsh导入名单Model> oldList = lsh导入名单Repository.findLatestRecord(model.电话号码, model.许可);
                    顾客记录汇总Model old汇总 = repository顾客记录汇总.findCusByPhoneAndPermit(model.电话号码, model.许可);
                    if (oldList.size() == 0) {
                        if (old汇总 == null) {
                            //不存在
                            if (model.车型编号 == null || model.客户级别 == null) {
                                entity.set是否线索("否");
                            } else {
                                entity.set是否线索("是");
                            }
                            entity.set是否有效线索("是");
                        } else {
                            //存在
                            if (model.车型编号 == null || model.客户级别 == null) {
                                errorMap.put("错误信息", "导入主动集客线索,意向车型、意向级别不能为空");
                                errorMap.put("电话", model.电话号码);
                                failList.add(errorMap);
                                continue;
                            } else {
                                entity.set是否线索("是");
                            }
                            entity.set是否有效线索("是");
                        }
                    } else {
                        //存在
                        if (model.车型编号 == null || model.客户级别 == null) {
                            errorMap.put("错误信息", "导入主动集客线索,意向车型、意向级别不能为空");
                            errorMap.put("电话", model.电话号码);
                            failList.add(errorMap);
                            continue;
                        } else {
                            entity.set是否线索("是");
                        }
                        List<Lsh导入名单Model> oldlist1 = lsh导入名单Repository.findByPhoneAndPermitAndTimeDesc1(model.电话号码, model.许可, startDate);
                        if (oldlist1.size() > 0) {
                            entity.set是否有效线索("否");
                        } else {
                            entity.set是否有效线索("是");
                        }
                    }
                }
            }

            //3 线索创建时间是否重复，重复不导入
            for (int j = 0; j < lsh导入名单list.size(); j++) {
                if (model.线索创建日期.equals(lsh导入名单list.get(j).get线索创建日期())) {
                    //有时间重复的，说明已经导入，当做成功的记录处理
                    //保存跳过的记录（当做失败）
                    succList.add(model.电话号码);
                    String erroRepeat线索 = "线索创建日期重复，不导入，顾客电话:" +
                            model.电话号码 + ",线索创建日趋：" + model.线索创建日期;
                    errorMap.put("respMsg", erroRepeat线索);
                    logger.error(erroRepeat线索);
                    continue;
                }
            }
            //4.获取市场编号
            Lsh市场设置Model model市场设置 = lsh市场设置Repository.getLsh市场设置Model(model.渠道,
                    model.来源分类, model.来源, model.许可);
            if (model市场设置 == null) {
                String error市场设置 = "市场设置没有信息，无法获取市场编号,渠道：" + model.渠道 + ",来源分类:" +
                        model.来源分类 + ",来源:" + model.来源 + ",许可:" + model.许可 + ",顾客电话:" + model.电话号码;
                errorMap.put("respMsg", error市场设置);
                logger.error(error市场设置);
                errorMap.put("错误信息", "无法获取市场信息:" + model.渠道 + "," + model.来源分类 + "," + model.来源);
                errorMap.put("电话", model.电话号码);
                failList.add(errorMap);
                continue;
            } else {
                // add by 黄永平 2017-06-23
                if ("停用".equals(model市场设置.get启用状态())) {
                    //如果是市场设置是停用，不再导入此条
                    String error市场设置 = "市场设置中处于停用状态,不导入此条，渠道：" + model.渠道 + ",来源分类:" +
                            model.来源分类 + ",来源:" + model.来源 + ",许可:" + model.许可 + ",顾客电话:" + model.电话号码;
                    errorMap.put("respMsg", error市场设置);
                    logger.error(error市场设置);
                    errorMap.put("错误信息", "市场设置中处于停用状态,不导入此条:" + model.渠道 + "," + model.来源分类 + "," + model.来源);
                    errorMap.put("电话", model.电话号码);
                    failList.add(errorMap);
                    continue;
                }
            }
            //5.保存导入名单
            //根据许可和活动代码获取活动编号
            entity.set许可(model.许可);
            entity.set顾客姓名(model.顾客姓名);
            entity.set电话号码(model.电话号码);
            entity.set顾客性别(model.顾客性别);
            entity.set渠道(model.渠道);
            entity.set来源(model.来源);
            entity.set市场编号(model市场设置.get市场编号());
            entity.set车型编号(model.车型编号);
            entity.set保有品牌(model.保有品牌);
            entity.set保有月数(model.保有月数);
            entity.set预计购车日期(model.预计购车日期);
            entity.set客户级别(model.客户级别);
            entity.set是否同行(model.是否同行);
            entity.set同行人数(model.同行人数);
            entity.set是否试驾(model.是否试驾);
            entity.set是否评估(model.是否评估);
            entity.set是否置换(model.是否置换);
            entity.set是否金融(model.是否金融);
            if (!"主动集客".equals(model.渠道)) {
                entity.set是否线索("是");
                if (lsh导入名单list.size() > 0) {
                    //查出数据，说明此名单不是有效线索
                    entity.set是否有效线索("否");
                } else {
                    entity.set是否有效线索("是");
                }
            }
            entity.set备注(model.备注);
            if (model.导入日期 == null) {
                entity.set导入日期(java.sql.Date.valueOf(LocalDate.now()));
            } else {
                entity.set导入日期(model.导入日期);
            }
            entity.set所属CDO(model.更新账号);
            entity.set所属销售顾问(email);
            entity.set下次跟进日期(model.下次跟进日期);
            if (model.线索创建日期 == null) {
                entity.set线索创建日期(java.sql.Date.valueOf(LocalDate.now()));
            } else {
                entity.set线索创建日期(model.线索创建日期);
            }
            entity.set预约编号(model.预约编号);
            entity.set顾客编号(model.顾客编号);
            entity.set推荐人顾客编号(model.推荐人顾客编号);
            entity.set战败去向(model.战败去向);
            entity.set战败去向备注(model.战败去向备注);
            entity.set更新账号(model.更新账号);
            if (model.更新时间 == null) {
                entity.set更新时间(DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date()));
            } else {
                entity.set更新时间(model.更新时间);
            }

            //2017-01-18日新增逻辑判断：
            //备注1：如果导入名单 所属销售顾问 为NULL，提示“该线索已存在”，否则提示“该线索已存在并分配”
            //备注2：如果顾客记录汇总 所属销售顾问 为NULL，提示“该线索已存在”，否则提示“该线索已存在并分配”
            //根据电话号码,许可 判断 顾客记录汇总 是否存在
            顾客记录汇总Model cus汇总 = repository顾客记录汇总.findCusByPhoneAndPermit(model.电话号码, model.许可);
            if (cus汇总 == null) {
                //如果顾客汇总无记录
                //判断导入名单3个月内是否存在 是否有效线索 = 是 的线索
                //如果存在，返回”该线索已存在”的提示信息（备注1），并且保存该线索（是否有效线索=否）
                //否则保存该线索（是否有效线索=是）
                if (lsh导入名单list.size() > 0) {
                    entity.set是否有效线索("否");
                    if (lsh导入名单list.get(0).get所属销售顾问() == null || "".equals(lsh导入名单list.get(0).get所属销售顾问())) {
                        errorMap.put("错误信息", "该线索已存在");
                        errorMap.put("电话", model.电话号码);
                        failList.add(errorMap);
                    } else {
                        errorMap.put("错误信息", "该线索已存在并分配");
                        errorMap.put("电话", model.电话号码);
                        failList.add(errorMap);
                    }
                } else {
                    entity.set是否有效线索("是");
                }
            } else {
                //如果顾客汇总有记录
                //如果顾客状态 IN （已订单、已交车、战败）
                if ("已订单".equals(cus汇总.get顾客状态()) || "已交车".equals(cus汇总.get顾客状态())
                        || "战败".equals(cus汇总.get顾客状态())) {

                    if (!"已交车".equals(cus汇总.get顾客状态())) {
                        //如果顾客状态 不等于 已交车，判断导入名单3个月内是否存在 是否有效线索 = 是 的线索。
                        //如果存在，返回”该线索已存在”的提示信息（备注1），并且保存该线索（是否有效线索=否）
                        //否则保存该线索（是否有效线索=是）
                        if (lsh导入名单list.size() > 0) {
                            entity.set是否有效线索("否");
                            if (lsh导入名单list.get(0).get所属销售顾问() == null || "".equals(lsh导入名单list.get(0).get所属销售顾问())) {
                                errorMap.put("错误信息", "该线索已存在");
                                errorMap.put("电话", model.电话号码);
                                failList.add(errorMap);
                            } else {
                                errorMap.put("错误信息", "该线索已存在并分配");
                                errorMap.put("电话", model.电话号码);
                                failList.add(errorMap);
                            }
                        } else {
                            entity.set是否有效线索("是");
                        }

                    } else {
                        //如果顾客状态 等于 已交车，获取交车日期，判断导入名单3个月内是否存在 是否有效线索 = 是 的线索
                        //如果不存在，保存该线索（是否有效线索=是）
                        //如果存在，判断 交车日期 是否小于 线索创建日期，
                        //如果是，返回”该线索已存在”的提示信息（备注1），并且保存该线索（是否有效线索=否）
                        //否则保存该线索（是否有效线索=是）
                        if (lsh导入名单list.size() > 0) {
                            //获取交车日期
                            List<报价单表Model> list报价单表 = repository报价单表.findBy顾客编号LimitOne(cus汇总.get顾客编号());
                            if (list报价单表.size() > 0) {
                                List<报价单表Model> list报价单表2 = repository报价单表.getListByInitQuoteNumberAnd是否还原点(list报价单表.get(0).get初始报价单号());
                                if (list报价单表2.size() > 0) {
                                    报价单表Model model报价单表 = list报价单表2.get(0);
                                    if (model报价单表.get交车() != null) {
                                        报价交车表Model model报价交车表 = repository报价交车.findOne(model报价单表.get交车());
                                        if (model报价交车表.get交车日期() != null) {
                                            Date date交车 = model报价交车表.get交车日期();
                                            Date date线索 = lsh导入名单list.get(0).get线索创建日期();
                                            if (date交车.getTime() < date线索.getTime()) {
                                                entity.set是否有效线索("否");
                                                if (lsh导入名单list.get(0).get所属销售顾问() == null || "".equals(lsh导入名单list.get(0).get所属销售顾问())) {
                                                    errorMap.put("错误信息", "该线索已存在");
                                                    errorMap.put("电话", model.电话号码);
                                                    failList.add(errorMap);
                                                } else {
                                                    errorMap.put("错误信息", "该线索已存在并分配");
                                                    errorMap.put("电话", model.电话号码);
                                                    failList.add(errorMap);
                                                }
                                            } else {
                                                entity.set是否有效线索("是");
                                            }
                                        } else {
                                            entity.set是否有效线索("否");
                                            if (lsh导入名单list.get(0).get所属销售顾问() == null || "".equals(lsh导入名单list.get(0).get所属销售顾问())) {
                                                errorMap.put("错误信息", "该线索已存在");
                                                errorMap.put("电话", model.电话号码);
                                                failList.add(errorMap);
                                            } else {
                                                errorMap.put("错误信息", "该线索已存在并分配");
                                                errorMap.put("电话", model.电话号码);
                                                failList.add(errorMap);
                                            }
                                        }
                                    } else {
                                        entity.set是否有效线索("否");
                                    }
                                } else {
                                    entity.set是否有效线索("否");
                                    if (lsh导入名单list.get(0).get所属销售顾问() == null || "".equals(lsh导入名单list.get(0).get所属销售顾问())) {
                                        errorMap.put("错误信息", "该线索已存在");
                                        errorMap.put("电话", model.电话号码);
                                        failList.add(errorMap);
                                    } else {
                                        errorMap.put("错误信息", "该线索已存在并分配");
                                        errorMap.put("电话", model.电话号码);
                                        failList.add(errorMap);
                                    }
                                }
                            } else {
                                entity.set是否有效线索("否");
                                if (lsh导入名单list.get(0).get所属销售顾问() == null || "".equals(lsh导入名单list.get(0).get所属销售顾问())) {
                                    errorMap.put("错误信息", "该线索已存在");
                                    errorMap.put("电话", model.电话号码);
                                    failList.add(errorMap);
                                } else {
                                    errorMap.put("错误信息", "该线索已存在并分配");
                                    errorMap.put("电话", model.电话号码);
                                    failList.add(errorMap);
                                }
                            }
                        } else {
                            entity.set是否有效线索("是");
                        }
                    }
                } else {
                    //如果顾客状态 NOT IN （已订单、已交车、战败），
                    // 无需判断导入名单，直接返回”该线索已存在”的提示信息（备注2），并且保存该线索（是否有效线索=否）
                    entity.set是否有效线索("否");
                    if (cus汇总.get所属销售顾问() == null || "".equals(cus汇总.get所属销售顾问())) {
                        errorMap.put("错误信息", "该线索已存在");
                        errorMap.put("电话", model.电话号码);
                        failList.add(errorMap);
                    } else {
                        errorMap.put("错误信息", "该线索已存在并分配");
                        errorMap.put("电话", model.电话号码);
                        failList.add(errorMap);
                    }

                }
            }


            Lsh导入名单Model newRecord = lsh导入名单Repository.save(entity);
            //保存成功的电话号码
            succList.add(newRecord.get电话号码());
            //6 如果是主动集客，还需要保存导入名单联系和附属表
            if ("主动集客".equals(model.渠道)) {
                //6.1 保存或者更新导入名单联系表
                Integer id联系记录编号 = null;
                Lsh导入名单联系表Model model导入名单联系表 = lsh导入名单联系表Repository.findByImportIdAndPermit(
                        newRecord.get导入编号(), model.许可);
                if (model导入名单联系表 == null) {
                    Lsh导入名单联系表Model n = new Lsh导入名单联系表Model();
                    n.set许可(model.许可);
                    n.set导入编号(newRecord.get导入编号());
                    n.set更新时间(DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date()));
                    n.set更新账号(model.更新账号);
                    Lsh导入名单联系表Model newLsh导入名单联系表 = lsh导入名单联系表Repository.save(n);
                    id联系记录编号 = newLsh导入名单联系表.get联系记录编号();
                } else {
                    model导入名单联系表.set许可(model.许可);
                    model导入名单联系表.set导入编号(newRecord.get导入编号());
                    model导入名单联系表.set更新时间(DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date()));
                    model导入名单联系表.set更新账号(model.更新账号);
                    lsh导入名单联系表Repository.save(model导入名单联系表);
                    id联系记录编号 = model导入名单联系表.get联系记录编号();
                }

                //6.2 保存lsh导入联系名单附属
                Lsh导入名单联系附属ModelPK pk = new Lsh导入名单联系附属ModelPK();
                pk.set联系记录编号(id联系记录编号);
                pk.set活动编号(newRecord.get活动编号());
                Lsh导入名单联系附属Model old附属 = lsh导入名单联系附属Repository.findOne(pk);
                if (old附属 == null) {
                    Lsh导入名单联系附属Model model导入名单联系附属 = new Lsh导入名单联系附属Model();
                    model导入名单联系附属.set联系记录编号(id联系记录编号);
                    model导入名单联系附属.set活动编号(newRecord.get活动编号());
                    lsh导入名单联系附属Repository.save(model导入名单联系附属);
                }
            }
            //7 如果预约时间不为空且预约销售顾问不为空，保存 待办事项 和lsh消息 表
            //2017-02-08新增： 并且是否线索和是否有效线索都为是
            if (model.预约时间 != null && model.预约销售顾问 != null
                    && "是".equals(newRecord.get是否有效线索()) && "是".equals(newRecord.get是否线索())) {
                Lsh待办事项Model model代办事项 = new Lsh待办事项Model();
                model代办事项.set许可(model.许可);
                model代办事项.set销售顾问(email);
                model代办事项.set待办分类("预约接待");
                model代办事项.set开始时间(model.预约时间);
                model代办事项.set结束时间(model.结束时间);
                //内容
                String content = "预约接待 推送预约到店 " + model.顾客姓名;
                model代办事项.set内容(content);
                model代办事项.set附属编号类型("线索");
                model代办事项.set附属编号(newRecord.get导入编号());
                model代办事项.set是否删除("否");
                model代办事项.set更新账号(model.更新账号);
                model代办事项.set更新时间(DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date()));
                Lsh待办事项Model new待办事项 = lsh待办事项Repository.save(model代办事项);

                //保存lsh消息
                String lshContent = null;
                if (model.预约时间.getTime() == model.结束时间.getTime()) {
                    lshContent = MessageContext.getAppointment(model.顾客姓名, model.预约时间.toString().substring(0, 19));
                } else {
                    lshContent = MessageContext.getAppointment(model.顾客姓名, model.预约时间.toString().substring(0, 10));
                }
                LshMsgUtils.getLshMsg(model.许可, model.更新账号, model.许可, email, "线索", lshContent, model.更新账号,
                        model.电话号码, newRecord.get导入编号().toString());
            }
        }
        map.put("succList", succList);
        map.put("succListSize", succList.size());
        map.put("failList", failList);
        map.put("failListSize", failList.size());
        return map;
    }

    @Override
    @Transactional
    public boolean saveAppointmentMsgs(GetAppointmentMsgRequest req) {
        try {
            //1 根据 许可，附属编号 查询 预约信息，如果存在，将此条预约信息标记为删除
            List<Lsh待办事项Model> list待办事项Model = lsh待办事项Repository.getLatestAppointmentMsg(req.附属编号, req.许可);
            if (list待办事项Model.size() > 0) {
                Lsh待办事项Model m = list待办事项Model.get(0);
                m.set是否删除("是");
                lsh待办事项Repository.save(m);
            }

            //2 新增 预约信息
            Lsh待办事项Model model = new Lsh待办事项Model();
            model.set许可(req.许可);
            model.set销售顾问(req.销售顾问);
            model.set待办分类("预约接待");
            model.set待办子类(req.待办子类);
            model.set待办小类(req.待办小类);
            model.set开始时间(req.开始时间);
            model.set结束时间(req.结束时间);
            model.set内容(req.内容);
            model.set备注(req.备注);
            model.set附属编号类型("线索");
            model.set附属编号(req.附属编号);
            model.set是否删除("否");
            model.set更新账号(req.更新账号);
            model.set更新时间(DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date()));
            Lsh待办事项Model newRecord = lsh待办事项Repository.save(model);

            //注释原因：DCC分配线索给SC后，不论是否选择预约时间，都会发送新的消息体给SC，所以不再需要这段代码
            /*//3 执行 需求4 中的语句，判断返回结果中的第一条（即最新一条消息）的更新时间，如果更新时间小于当前时间 – 30分钟，执行 新增消息 操作。 30分钟这个时间可以作为参数，此时间由前端控制
            List list = messageRepository.getLshMessageByIdAndPermit(req.附属编号.toString(), req.许可);

            if (list.size() > 0) {
                Map map = (Map) list.get(0);
                Timestamp updateTime = (Timestamp) map.get("更新时间");
                //SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                //Date date = sdf.parse(updateTime);
                long dt = updateTime.getTime();//数据库时间戳
                long times = req.比较时间.getTime();//传入时间戳
                if (dt > times) {
                    //不新增消息
                    return true;
                }
            }
            //4.其他情况，新增消息
            Date date = null;
            String messageType = null;
            if (req.消息分类 == null) {
                messageType = "线索";
            } else {
                messageType = req.消息分类;
            }
            if (req.消息创建时间 == null) {
                date = DateFormatUtils.getFormatDate("yyyy-MM-dd HH:mm:ss", new Date());
            } else {
                date = req.消息创建时间;
            }
            Lsh导入名单Model getPhoneModel = lsh导入名单Repository.findOne(Integer.valueOf(req.消息附属Id));
            LshMsgUtils.getLshMsg(req.许可, req.发送人, req.许可, req.接收人, messageType, req.消息内容, req.更新账号,
                    getPhoneModel == null ? null : getPhoneModel.get电话号码(), req.附属Id类型, req.消息附属Id, req.消息备注, req.删除账号, date);

            //  新增极光推送
            List<String> userList = new ArrayList<>();
            userList.add(req.接收人);
            JPush.sendPushForAndroidAndIos(req.消息内容, req.消息内容, JsonObjectUtils.getJsonObject("",
                    "", "", getPhoneModel == null ? "" : getPhoneModel.get电话号码(), "", ""), userList, JPush.Platforms.iTask);*/
            return true;
        } catch (Exception e) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            logger.error("数据保存异常。", e);
            return false;
        }
    }

    @Override
    public List getActivityInviteList(GetLshActivityRequest req) {
        return messageRepository.getActivityInviteList(req.permit, req.activityCodeList);
    }

//    /**
//     * 保存活动前邀约名单
//     */
//    @Override
//    @Transactional
//    public Map saveActivityBeforInviteList(List<SaveActivityInviteRequest> reqList) throws IOException, ClassNotFoundException {
//        Timestamp timestamp = DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date());
//        Calendar c = Calendar.getInstance();
//        c.add(Calendar.MONTH, -2);
//        Date dtTime = getFormatDate("yyyy-MM-01", c.getTime());//3个自然月前
//        List succList = new ArrayList();
//        List failList = new ArrayList();
//        Map result = new HashMap();
//        for (int i = 0; i < reqList.size(); i++) {
//            Map errorMap = new HashMap();
//            List newRecords = new ArrayList();
//            SaveActivityInviteRequest s = reqList.get(i);
//            用户Model model销售 = repository用户.findUserByPermitAnd人员姓名NotDel(s.许可, s.所属销售顾问);
//            Lsh导入名单Model lastImport = new Lsh导入名单Model();
//            if (model销售 == null) {
//                s.所属销售顾问 = null;
//            } else {
//                s.所属销售顾问 = model销售.get用户名();
//            }
//
//            //1.从导入名单表中，根据电话号码、活动编号判断是否为重复导入数据
//            List<Lsh导入名单Model> old导入List = lsh导入名单Repository.findByPhoneAndActivityCode(s.电话号码, s.活动编号, s.许可);
//            if (old导入List.size() > 0) {
//                logger.warn("有此活动编号的导入名单");
//                errorMap.put("电话", s.电话号码);
//                errorMap.put("错误信息", "有此活动编号的导入名单");
//                failList.add(errorMap);
//                continue;
//            }
//
//            //判断顾客记录汇总是否存在
//            顾客记录汇总Model old汇总 = repository顾客记录汇总.findCusByPhoneAndPermit(s.电话号码, s.许可);
//
//            //判断是否存在导入名单(三个月)
//            List<Lsh导入名单Model> oldList = lsh导入名单Repository.findByPhoneAndPermitAndTimeDesc(s.电话号码, s.许可, dtTime);
//
//            if (old汇总 != null) {
//                //汇总存在：是否线索=是
//                if (oldList.size() > 0) {
//                    Lsh导入名单Model m = oldList.get(0);
//                    //查询进店记录表，进店日期必须大于等于线索创建日期，才算进店
//                    Date dtTimes = m.get线索创建日期();
//                    java.sql.Date dt = new java.sql.Date(dtTimes.getTime());
//                    List<顾客进店记录表Model> list进店记录 = repository顾客进店记录表.findBy进店日期And许可(old汇总.get顾客编号(), s.许可, dt);
//                    if (list进店记录.size() > 0) {
//                        //进店
//                        List<顾客订单记录Model> list订单 = repository顾客订单记录.findByDates(dtTimes, s.许可, old汇总.get顾客编号());
//                        if ("本月".equals(old汇总.get顾客状态()) || "活跃".equals(old汇总.get顾客状态()) ||
//                                "休眠".equals(old汇总.get顾客状态())) {
//                            //如果顾客状态是活跃/休眠/本月，sc/保留
//                            Lsh导入名单Model newModel = (Lsh导入名单Model) CloneUtils.deepClone(m);
//                            newModel.set导入编号(null);
//                            newModel.set许可(s.许可);
//                            newModel.set顾客姓名(s.顾客姓名);
//                            newModel.set电话号码(s.电话号码);
//                            newModel.set是否线索("是");
//
//                            newModel.set车型编号(null);//2017-03-20：所有活动都不需要保存车型
//
//
//                            //判断是否有效线索：三个月内有没有导入名单数据
//                            List<Lsh导入名单Model> oldlist1 = lsh导入名单Repository.findByPhoneAndPermitAndTimeDesc1(s.电话号码, s.许可, dtTime);
//                            if (oldlist1.size() > 0) {
//                                newModel.set是否有效线索("否");
//                            } else {
//                                newModel.set是否有效线索("是");
//                            }
//                            newModel.set更新账号(s.更新账号);
//                            newModel.set导入日期(java.sql.Date.valueOf(LocalDate.now()));
//                            newModel.set线索创建日期(java.sql.Date.valueOf(LocalDate.now()));
//                            newModel.set更新时间(timestamp);
//                            newModel.set导入状态(0);
//                            lastImport = lsh导入名单Repository.save(newModel);
//                            saveLshImporOthers(s.许可, s.更新账号, lastImport.get导入编号(), s.活动编号);
//                            newRecords.add(lastImport);
//                        } else if ("战败".equals(old汇总.get顾客状态()) || list订单.size() > 0) {
//                            Lsh导入名单Model ld = getLshImportRec(s);
//                            ld.set所属CDO(m.get所属CDO());
//                            lastImport = lsh导入名单Repository.save(ld);
//                            saveLshImporOthers(s.许可, s.更新账号, lastImport.get导入编号(), s.活动编号);
//                            newRecords.add(lastImport);
//                        } else {
//                            Lsh导入名单Model ld2 = getLshImportRec(s);
//                            saveLshImporOthers(s.许可, s.更新账号, ld2.get导入编号(), s.活动编号);
//                            newRecords.add(ld2);
//                        }
//
//                    } else {
//                        //未进店
//                        lastImport = doNotInImportRecords(s, dtTime, m, newRecords, null);
//                    }
//                } else {
//                    //未进店
//                    lastImport = doNotInImportRecords(s, dtTime, null, newRecords, old汇总);
//                }
//            } else {
//                //顾客记录汇总不存在
//                if (oldList.size() > 0) {
//                    Lsh导入名单Model m = oldList.get(0);
//                    //导入名单存在，未进店处理,是否线索=是
//                    lastImport = doNotInImportRecords(s, dtTime, m, newRecords, null);
//                } else {
//                    //不存在，是否线索=否，是否有效线索=是
//                    Lsh导入名单Model mm = getLshImportRec(s);
//                    mm.set是否线索("否");
//                    mm.set是否有效线索("是");
//                    lastImport = lsh导入名单Repository.save(mm);
//                    saveLshImporOthers(s.许可, s.更新账号, lastImport.get导入编号(), s.活动编号);
//                    newRecords.add(lastImport);
//                }
//
//            }
//            if (s.所属销售顾问 != null && !"".equals(s.所属销售顾问)) {
//                //插入待办事项表
//                Lsh待办事项Model lsh待办事项Model = new Lsh待办事项Model();
//                lsh待办事项Model.set许可(s.许可);
//                lsh待办事项Model.set销售顾问(s.所属销售顾问);
//                lsh待办事项Model.set开始时间(DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", s.活动开始日期));
//                lsh待办事项Model.set结束时间(DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", s.活动结束日期));
//                lsh待办事项Model.set内容("预约接待 推送预约到店 " + s.顾客姓名);
//                lsh待办事项Model.set附属编号(lastImport.get导入编号());
//                lsh待办事项Model.set是否删除("否");
//                lsh待办事项Model.set更新账号(s.更新账号);
//                lsh待办事项Model.set待办分类("预约接待");
//                lsh待办事项Model.set附属编号类型("线索");
//                lsh待办事项Model.set更新时间(DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date()));
//                lsh待办事项Repository.save(lsh待办事项Model);
//            }
//            succList.add(newRecords);
//        }
//        result.put("succList", succList);
//        result.put("succListSize", succList.size());
//        result.put("failList", failList);
//        result.put("failListSize", failList.size());
//        return result;
//    }

    @Override
    public List getActivityBeforInviteList(String dlr, List<GetLshActivityRequest> req) {
//        List result = new ArrayList();
//        for (int i = 0; i < reList.size(); i++) {
//            GetLshActivityRequest req = reList.get(i);
//            //先查询出LSH导入名单是否有数据
//            List listImport = messageRepository.getActivityBeforInviteListFromImport(req.permit, req.phone, req.人员姓名);
//            if (listImport.size() > 0) {
//                result.addAll(listImport);
//                continue;
//            } else {
//                //如果lsh导入名单没有数据
//                List cusRecordsList = messageRepository.getActivityBeforInviteListFromRecords(req.permit, req.phone, req.人员姓名);
//                if (cusRecordsList.size() > 0) {
//                    result.addAll(cusRecordsList);
//                } else {
//                    //lsh导入名单和顾客记录汇总都没有数据,拼接json字符串返回
//                    List empty = new ArrayList();
//                    Map map = new HashMap();
//                    map.put("顾客姓名", req.人员姓名);
//                    map.put("顾客性别", "");
//                    map.put("渠道", "");
//                    map.put("来源", "");
//                    map.put("客户级别", "");
//                    map.put("所属CDO", "");
//                    map.put("所属销售顾问", "");
//                    map.put("是否存在", "否");
//                    map.put("电话号码", req.phone);
//                    empty.add(0, map);
//                    result.addAll(empty);
//                }
//            }
//        }
//        return result;
        List<Map> reList = new ArrayList<>();
        List<Lsh导入名单Model> imNameMoLiDlr = lsh导入名单Repository.getImportMoListByPermit(dlr);
        List<顾客记录汇总Model> cusReMoLiDlr = repository顾客记录汇总.getCusMoListByPermit(dlr);
        List<用户Model> userMoLiDlr = repository用户.findAllSaleMan(dlr);
        for (GetLshActivityRequest re : req) {
            // 先在LSH导入名单中找是否有数据
            List<Lsh导入名单Model> imNameMoLi = imNameMoLiDlr.stream().filter(i -> i.get电话号码().equals(re.phone)
                    && "是".equals(i.get是否有效线索())).collect(Collectors.toList());
            if (imNameMoLi != null && imNameMoLi.size() != 0) {
                imNameMoLi.sort((Lsh导入名单Model i1, Lsh导入名单Model i2) -> i2.get更新时间().compareTo(i1.get更新时间()));
                Lsh导入名单Model mo = imNameMoLi.get(0);
                Map<String, Object> map = new HashMap<>();
                map.put("顾客姓名", re.人员姓名);
                map.put("电话号码", re.phone);
                map.put("顾客性别", "".equals(mo.get顾客性别()) ? null : mo.get顾客性别());
                map.put("渠道", mo.get渠道());
                map.put("来源", mo.get来源());
                map.put("是否存在", "是");
                map.put("客户级别", mo.get客户级别());
                map.put("表来源", "1");
                map.put("所属CDO", mo.get所属CDO());
                Optional<用户Model> userMoOp = userMoLiDlr.stream().filter(i -> i.get用户名().equals(mo.get所属销售顾问())).findFirst();
                if (userMoOp.isPresent()) {
                    map.put("所属销售顾问", userMoOp.get().get人员姓名());
                } else {
                    map.put("所属销售顾问", null);
                }
                reList.add(map);
                continue;
            }
            // LSH导入名单找不到，到顾客记录汇总找
            List<顾客记录汇总Model> cusReMoLi = cusReMoLiDlr.stream().filter(i -> i.get电话号码().equals(re.phone)).collect(Collectors.toList());
            if (cusReMoLi != null && cusReMoLi.size() != 0) {
                cusReMoLi.sort((顾客记录汇总Model i1, 顾客记录汇总Model i2) -> i2.get更新时间().compareTo(i1.get更新时间()));
                顾客记录汇总Model mo = cusReMoLi.get(0);
                Map<String, Object> map = new HashMap<>();
                map.put("顾客姓名", re.人员姓名);
                map.put("电话号码", re.phone);
                map.put("顾客性别", "".equals(mo.get顾客性别()) ? null : mo.get顾客性别());
                map.put("渠道", mo.get顾客渠道());
                map.put("来源", mo.get顾客来源());
//                map.put("是否存在", "是");
                map.put("客户级别", mo.get新顾客级别());
                map.put("表来源", "0");
                map.put("所属CDO", "");
                Optional<用户Model> userMoOp = userMoLiDlr.stream().filter(i -> i.get用户名().equals(mo.get所属销售顾问())).findFirst();
                if (userMoOp.isPresent()) {
                    map.put("所属销售顾问", userMoOp.get().get人员姓名());
                } else {
                    map.put("所属销售顾问", null);
                }
                reList.add(map);
                continue;
            }
            // 既不存在于 LSH导入单名，也不存在于 顾客记录汇总
            Map<String, Object> map = new HashMap<>();
            map.put("顾客姓名", re.人员姓名);
            map.put("电话号码", re.phone);
            map.put("顾客性别", "");
            map.put("渠道", "");
            map.put("来源", "");
            map.put("是否存在", "否");
            map.put("客户级别", "");
            map.put("所属CDO", "");
            map.put("所属销售顾问", "");
            reList.add(map);
        }
        return reList;
    }

    @Override
    public List getActivityAfterInviteList(List<GetLshActivityRequest> reqList) {
        //非展厅 销售顾问是空 查出来返回，是否冲突为否，销售顾问是否存在为是
        //展厅 逻辑不变
        List list = new ArrayList();
        for (int i = 0; i < reqList.size(); i++) {
            GetLshActivityRequest g = reqList.get(i);
            if (g.人员姓名 == null) {
                g.人员姓名 = "";
            }
            if (g.销售顾问姓名 == null) {
                g.销售顾问姓名 = "";
            }
            //1、判断销售顾问是否存在
            用户Model model用户 = null;
            if (!Strings.isNullOrEmpty(g.销售顾问姓名)) {
                model用户 = repository用户.findUserByPermitAnd人员姓名(g.permit, g.销售顾问姓名);
                if (model用户 == null) {
                    //销售顾问不存在
                    Map map = new HashMap();
                    map.put("销售顾问是否存在", "否");
                    map.put("顾客姓名", g.人员姓名);
                    map.put("电话号码", g.phone);
                    map.put("顾客性别", "");
                    map.put("渠道", "");
                    map.put("来源", "");
                    map.put("客户级别", "");
                    map.put("原销售顾问", "");
                    map.put("所属CDO", "");
                    map.put("销售顾问", g.销售顾问姓名);
                    list.add(map);
                    continue;
                }
            }

            if ("否".equals(g.是否展厅)) {//非展厅
                if (Strings.isNullOrEmpty(g.销售顾问姓名)) {//去库里找两张表，先找 顾客记录汇总表
                    顾客记录汇总Model old汇总 = repository顾客记录汇总.findCusByPhoneAndPermit(g.phone, g.permit);
                    用户Model model销售 = null;
                    Map map = new HashMap();
                    map.put("顾客姓名", g.人员姓名);
                    map.put("电话号码", g.phone);
                    map.put("顾客性别", "");
                    map.put("渠道", "");
                    map.put("来源", "");
                    map.put("客户级别", "");
                    map.put("原销售顾问", "");
                    map.put("所属CDO", "");
                    if (old汇总 != null) {
                        model销售 = repository用户.findUserByPermitAnd用户名NotDel(g.permit, old汇总.get所属销售顾问());
                        if (model销售 == null) {
                            g.销售顾问姓名 = null;
                        } else {
                            g.销售顾问姓名 = model销售.get人员姓名();
                        }
                        map.put("是否冲突", "否");
                        map.put("销售顾问是否存在", "是");
                        map.put("销售顾问", g.销售顾问姓名);
                        list.add(map);
                        continue;
                    } else {
                        Calendar c = Calendar.getInstance();
                        c.setTime(new Date());
                        c.add(Calendar.MONTH, -2);
                        Date startTime = getFormatDate("yyyy-MM-01 hh:mm:ss", c.getTime());//3个自然月前
                        Date endTime = getFormatDate("yyyy-MM-dd hh:mm:ss", new Date());
                        List<Lsh导入名单Model> 导入名单Model = lsh导入名单Repository.isAvailableClue(g.phone, g.permit, startTime, endTime);
                        if (导入名单Model.size() != 0) {//有数据
                            model销售 = repository用户.findUserByPermitAnd用户名NotDel(g.permit, 导入名单Model.get(0).get所属销售顾问());
                            if (model销售 == null) {
                                g.销售顾问姓名 = null;
                            } else {
                                g.销售顾问姓名 = model销售.get人员姓名();
                            }
                            map.put("是否冲突", "否");
                            map.put("销售顾问是否存在", "是");
                            map.put("销售顾问", g.销售顾问姓名);
                            list.add(map);
                            continue;
                        } else {
                            map.put("是否冲突", "否");
                            map.put("销售顾问是否存在", "是");//非展厅销售顾问不填不做校验
                            map.put("销售顾问", "");
                            list.add(map);
                            continue;
                        }
                    }
                } else {//非展厅,销售顾问不为空
                    Map map = new HashMap();
                    map.put("销售顾问是否存在", "是");
                    map.put("顾客姓名", g.人员姓名);
                    map.put("电话号码", g.phone);
                    map.put("顾客性别", "");
                    map.put("渠道", "");
                    map.put("来源", "");
                    map.put("客户级别", "");
                    map.put("原销售顾问", "");
                    map.put("所属CDO", "");
                    map.put("销售顾问", g.销售顾问姓名);
                    //2.先从顾客记录汇总取数据
                    List cusRecordsList = messageRepository.getActivityAfterInviteListFromRecords(g.permit, g.phone, g.人员姓名, g.销售顾问姓名);
                    if (cusRecordsList.size() > 0) {
                        Map cusRecordMap = (Map) cusRecordsList.get(0);
                        String nameEmail = (String) cusRecordMap.get("所属销售顾问");
                        if (model用户.get用户名().equals(nameEmail)) {
                            //email相同,不冲突
                            cusRecordMap.put("是否冲突", "否");
                        } else {
                            //email不同，冲突
                            logger.info("NO MESSAGE");
                            cusRecordMap.put("是否冲突", "是");
                        }
                        list.addAll(cusRecordsList);
                        continue;
                    }else {
                        //3.然后查询LSH导入名单数据
                        List listImport = messageRepository.getActivityAfterInviteListFromImport(g.permit, g.phone, g.人员姓名, g.销售顾问姓名);
                        if (listImport.size() > 0) {
                            Map importMap = (Map) listImport.get(0);
                            String name = (String) importMap.get("所属销售顾问");
                            if (model用户.get用户名().equals(name)) {
                                //email相同,不冲突
                                importMap.put("是否冲突", "否");
                            } else {
                                //email不同,冲突
                                importMap.put("是否冲突", "是");
                            }
                            list.addAll(listImport);
                            continue;
                        }else {
                            //4.如果导入名单和顾客记录汇总都没有数据
                            map.put("是否冲突", "否");
                            list.add(map);
                            continue;
                        }
                    }
                }
            } else {//展厅
                //1、判断销售顾问是否存在
                model用户 = repository用户.findUserByPermitAnd人员姓名(g.permit, g.销售顾问姓名);
                if (model用户 == null) {
                    //销售顾问不存在
                    Map map = new HashMap();
                    map.put("销售顾问是否存在", "否");
                    map.put("顾客姓名", g.人员姓名);
                    map.put("电话号码", g.phone);
                    map.put("顾客性别", "");
                    map.put("渠道", "");
                    map.put("来源", "");
                    map.put("客户级别", "");
                    map.put("原销售顾问", "");
                    map.put("所属CDO", "");
                    map.put("销售顾问", g.销售顾问姓名);
                    list.add(map);
                    continue;
                } else {
                    //3.先从顾客记录汇总取数据
                    List cusRecordsList = messageRepository.getActivityAfterInviteListFromRecords(g.permit, g.phone, g.人员姓名, g.销售顾问姓名);
                    if (cusRecordsList.size() > 0) {
                        Map cusRecordMap = (Map) cusRecordsList.get(0);
                        String nameEmail = (String) cusRecordMap.get("所属销售顾问");
                        if (model用户.get用户名().equals(nameEmail)) {
                            //email相同,不冲突
                            cusRecordMap.put("是否冲突", "否");
                        } else {
                            //email不同，冲突
                            logger.info("NO MESSAGE");
                            cusRecordMap.put("是否冲突", "是");
                        }
                        list.addAll(cusRecordsList);
                        continue;
                    } else {
                        //2.再查询LSH导入名单数据
                        List listImport = messageRepository.getActivityAfterInviteListFromImport(g.permit, g.phone, g.人员姓名, g.销售顾问姓名);
                        if (listImport.size() > 0) {
                            Map importMap = (Map) listImport.get(0);
                            String name = (String) importMap.get("所属销售顾问");
                            if (model用户.get用户名().equals(name)) {
                                //email相同,不冲突
                                importMap.put("是否冲突", "否");
                            } else {
                                //email不同,冲突
                                importMap.put("是否冲突", "是");
                            }
                            list.addAll(listImport);
                            continue;
                        } else {
                            //4.如果顾客记录汇总和导入名单都没有数据
                            Map map = new HashMap();
                            map.put("销售顾问是否存在", "是");
                            map.put("顾客姓名", g.人员姓名);
                            map.put("电话号码", g.phone);
                            map.put("顾客性别", "");
                            map.put("渠道", "");
                            map.put("来源", "");
                            map.put("客户级别", "");
                            map.put("原销售顾问", "");
                            map.put("所属CDO", "");
                            map.put("销售顾问", g.销售顾问姓名);
                            list.add(map);
                        }
                    }
                }
            }
        }
        return list;
    }

    /**
     * 保存活动前邀约名单
     * <p>
     * 活动前导入
     * 对于不存在于系统的顾客（不存在于顾客记录汇总，不存在于导入名单或者是以名单的形式存在于导入名单），
     * 以名单的形式保存（渠道是主动集客，关联活动，不保存意向车型），并推送给CDO。如果同一个顾客被多个活动邀约（活动前导入），以最后一次导入的活动为准。
     * 如果同一个电话号码在导入名单中查询到多个名单（历史数据。以前的导入名单表只有新增操作，没有更新操作），
     * 保留最新的一条名单信息并更新（更新活动和姓名）， 其他名单设置为无效。
     * [2017-7-10]新增：更新时需要更新线索创建日期 = 当天
     * 对于存在于系统的顾客（存在于顾客记录汇总 或者 以线索的形式存在于导入名单）
     * 如果是进过店的线索
     * 顾客状态是 活跃，休眠，本月的：在导入名单表中保存顾客信息（如果三个自然月内存在一条有效线索，将活动与该线索关联并更新姓名；
     * 如果三个自然月内存在多条有效线索，将活动与最后一条有效线索关联并更新姓名，其它有效线索不做处理；如果三个自然月内不存在有效线索，
     * 新增一条有效线索，渠道，顾客级别，销售顾问等信息继承自顾客记录汇总，意向车型不继承。）
     * [2017-7-11]新增：当导入名单中的所属销售顾问不为空的时候，新增/更新 待办事项表，待办事项表新增时，写入的数据参考原活动前导入；
     * 更新时，只更新待办事项表的开始时间和结束时间（通过附属编号类型 = ‘线索’，附属编号 = 导入编号，许可 = 许可，待办分类 = ‘预约接待’，
     * 待办子类 = NULL，是否删除 = ‘否’ 来确定更新的待办事项） tag
     * 顾客状态是订单，交车，战败的：在导入名单表中保存顾客信息（与2.1.I的区别在于：如果三个自然月内不存在有效线索，新增一条有效线索，
     * 渠道为主动集客，CDO为最近一次对其邀约的CDO，意向车型为空）
     * [2017-7-11]新增：如果三个月内存在有效线索（多条的话取最新一条），取最新一条的线索创建日期和进店日期对比，
     * 如果线索创建日期 > 进店日期（说明新线索和订单，交车，战败没关系），更新线索数据，更新原则和之前逻辑一样；
     * 如果 线索创建日期 <= 进店日期（说明该线索已订单，交车，战败，线索生命周期结束），新增一条有效线索，新增逻辑同三个月内不存在有效线索。
     * [2017-7-11]新增：同tag
     * 如果是未进店的线索
     * 如果导入名单表中，三个月内存在有效线索，将最新的一条有效线索与活动关联，并更新姓名。
     * [2017-7-11]新增：同tag
     * 如果导入名单表中，三个月内不存在有效线索，新增一条线索，渠道为主动集客，CDO为最近一次对其邀约的CDO，意向车型为空
     * [2017-7-11]新增：同tag
     */
    @Override
    @Transactional
    public ResultData saveActivityBeforInviteList(String dealer, String user, List<SaveActivityInviteRequest> req) {
        logger.info("保存活动前邀约名单，参数为" + JsonObjectUtils.writeAsJson(req));
        Integer iniNum = 500; // 本导入功能，已经出现一次3000条的操作，初始化ArrayList时，不能使用默认值
        String errMsg = "保存活动前邀约名单异常";
        try {
            // 取本许可下，需要使用的数据
            List<顾客记录汇总Model> cusMoLiDlr = repository顾客记录汇总.getCusMoListByPermit(dealer);
            List<Lsh导入名单Model> imMoLiDlr = lsh导入名单Repository.getImportMoListByPermit(dealer);
            List<顾客进店记录表Model> cusInMoLiDlr = repository顾客进店记录表.getListByPermit(dealer);
            List<Lsh市场设置Model> maSetMoLiDlr = lsh市场设置Repository.getMoByDlr(dealer);
            List<用户Model> userMoLiDlr = repository用户.findAllSaleMan(dealer);
            List<Lsh导入名单联系表Model> conMoLiDlr = lsh导入名单联系表Repository.findAllConMoByDlr(dealer);
            List<Lsh待办事项Model> toDoMoLiDlr = lsh待办事项Repository.findAllByDlr(dealer);
            List<Lsh导入名单联系附属Model> apMoLiDlr = lsh导入名单联系附属Repository.findAll(); // 无许可取全表
            // 三种情况处理的请求insertList
            List<SaveActivityInviteRequest> insertList1 = new ArrayList<>(iniNum);
            List<SaveActivityInviteRequest> insertList2 = new ArrayList<>(iniNum);
            List<SaveActivityInviteRequest> insertList3 = new ArrayList<>(iniNum);
            // 保存已经处理好的导入名单记录
            List<Lsh导入名单Model> reList = new ArrayList<>(iniNum);
            List<SaveActivityInviteRequest> reReqLi = new ArrayList<>(iniNum); // 与reList同步处理的请求列表
            List<Lsh导入名单Model> imLi = new ArrayList<>(iniNum); // 导入名单待新增数据
            List<SaveActivityInviteRequest> imReqLi = new ArrayList<>(iniNum); // 与imLi同步处理的请求列表
            List<Lsh导入名单联系表Model> sycConLi = new ArrayList<>(iniNum); // 1.用来保存同步更新的联系表数据
            List<Lsh导入名单联系附属Model> sycApLi = new ArrayList<>(iniNum); // 2.与1同步更新的附属表数据
            List<Lsh导入名单联系附属Model> deApLi = new ArrayList<>(iniNum); // 3.待删除的附属表数据
            List<Lsh导入名单联系附属Model> apLi = new ArrayList<>(iniNum); // 4.待3处理后，新增数据的附属表（3.4实质是更新，但联合主键不能用save更新）
            for (SaveActivityInviteRequest re : req) {
                // case1.顾客记录汇总中不存在
                // 不存在于系统 指是的：顾客记录汇总中不存在，并且(导入名单中不存在，或者存在，但还是名单)
                //                  相当于 顾客记录汇总中根据许可，电话查不到 && (导入名单中根据许可电话查不到 || 查到记录中"是否线索" = "否", "是否有效线索" = "是"）
                // 在当前许可的顾客记录汇总中，查找对应电话号码的记录，主键约束，只有一条记录
                Optional<顾客记录汇总Model> cusMoOp = cusMoLiDlr.stream().filter(i -> i.get电话号码().equals(re.电话号码)).findFirst();
                // 在当前许可的LSH导入名单中，查找对应电话号码的记录列表，可能有多条记录
                List<Lsh导入名单Model> imMoList = imMoLiDlr.stream().filter(i -> i.get电话号码().equals(re.电话号码)).collect(Collectors.toList());
                String sex = re.顾客性别.trim().length() == 0 ? "男" : re.顾客性别; // 空串代表没数据，默认男
                if (!cusMoOp.isPresent()) { // 顾客记录汇总中查不到
                    if (imMoList == null || imMoList.size() == 0) { // case1.1 导入名单中查不到，作为新数据插入
                        insertList1.add(re);
                        continue; // 处理下一条记录
                    } // case1.2 导入名单中可以查到，根据存在的数据情况（名单，线索）处理
                    Boolean existName = false; // 是否存在名单数据
                    Boolean existLead = false; // 是否存在线索数据
                    List<Lsh导入名单Model> nameList = new ArrayList<>(iniNum); // 待处理名单list
                    List<Lsh导入名单Model> leadList = new ArrayList<>(iniNum); // 待处理线索list
                    for (Lsh导入名单Model importMo : imMoList) {
                        if ("否".equals(importMo.get是否线索()) && "是".equals(importMo.get是否有效线索())) { // 导入名单中存在名单
                            existName = true;
                            nameList.add(importMo);
                        } else if ("是".equals(importMo.get是否线索())) { // 导入名单中存在线索
                            existLead = true;
                            leadList.add(importMo);
                        } // 是否线索，是否有效线索   都是否，在后面新增数据
                    }
                    if (existName && existLead) { // 既存在名单，又存在线索
                        for (Lsh导入名单Model mo : nameList) { // 全部名单有效线索置否
                            mo.set是否有效线索("否");
                        }
                        // 线索记录中最新一条记录更新活动编号与名字，其他不管
//                        leadList.sort((Lsh导入名单Model m1, Lsh导入名单Model m2) -> m2.get线索创建日期().compareTo(m1.get线索创建日期()));
//                        Integer toModifyImNum = leadList.get(0).get导入编号();
//                        // 更新导入名单中的活动编号与顾客信息
//                        lsh导入名单Repository.updateCodeTelSexByCode(re.活动编号, re.顾客姓名, sex, toModifyImNum);
//                        saveLshImportOthers(toModifyImNum, dealer, user, leadList.get(0).get活动编号(), re.活动编号,
//                                sycConLi, sycApLi, apLi, deApLi, conMoLiDlr, apMoLiDlr);
                        updateLast(leadList, re, sex, dealer, user, imLi, imReqLi,
                                sycConLi, sycApLi, apLi, deApLi, conMoLiDlr, apMoLiDlr);
                    } else if (existName) { // 只存在名单，将最新一条编号名字更新，其他数据是否有效线索置否
                        nameList.sort((Lsh导入名单Model m1, Lsh导入名单Model m2) -> m2.get线索创建日期().compareTo(m1.get线索创建日期()));
                        for (int i = 0; i < nameList.size(); i++) {
                            if (i == 0) {
                                // 特别的更新，用的重载方法
//                                lsh导入名单Repository.updateCodeTelSexByCode(re.活动编号, re.顾客姓名, sex, nameList.get(i).get导入编号(), "主动集客", null);
                                Integer oldActNum = nameList.get(0).get活动编号();
                                Lsh导入名单Model mo = nameList.get(0);
                                mo.set导入状态(0);
                                mo.set活动编号(re.活动编号);
                                mo.set顾客姓名(re.顾客姓名);
                                mo.set顾客性别(sex);
                                mo.set渠道("主动集客");
                                mo.set车型编号(null);
                                mo.set线索创建日期(java.sql.Date.valueOf(LocalDate.now()));
                                imLi.add(mo);
                                imReqLi.add(re);
                                // 更新导入名单附属表，更新导入名单联系表
                                saveLshImportOthers(mo.get导入编号(), dealer, user, oldActNum, re.活动编号,
                                        sycConLi, sycApLi, apLi, deApLi, conMoLiDlr, apMoLiDlr);
                            } else {
                                nameList.get(i).set是否有效线索("否");
                            }
                        }
                    } else if (existLead) { // 只存在线索，其中应该只有一条有效线索，更新此记录活动编号与名字，若有多条，更新最新的一条
//                        // 寻找3个月内的有效线索（3个月指自然月，即当天到当月第1天，并且往前推2个月，比如20170417，3个月内指20170201~20170417）
//                        LocalDate beginDate = LocalDate.now().minusMonths(2).withDayOfMonth(1); // 前3个自然月的开始
//                        List<Lsh导入名单Model> tmp = imMoList.stream().filter(
//                                i -> "是".equals(i.get是否线索()) && "是".equals(i.get是否有效线索())
//                                        && beginDate.minusDays(1).isBefore(i.get线索创建日期().toLocalDate())
//                                        && i.get线索创建日期().toLocalDate().isBefore(LocalDate.now().plusDays(1)))
//                                .collect(Collectors.toList());
//                        if (tmp == null || tmp.size() == 0) { // 如果不存在则新增
//                            insertList2.add(re);
//                        } else { // 存在则更新最新的一条
//                            tmp.sort((Lsh导入名单Model m1, Lsh导入名单Model m2) -> m2.get线索创建日期().compareTo(m1.get线索创建日期()));
//                            for (int i = 0; i < tmp.size(); i++) {
//                                if (i == 0) {
//                                    lsh导入名单Repository.updateCodeTelSexByCode(re.活动编号, re.顾客姓名, sex, tmp.get(i).get导入编号());
//                                    saveLshImportOthers(tmp.get(i).get导入编号(), dealer, user, tmp.get(i).get活动编号(), re.活动编号);
//                                }
//                            }
//                        }
                        threeMonthProcess(leadList, insertList2, re, sex, dealer, user, imLi, imReqLi,
                                sycConLi, sycApLi, apLi, deApLi, conMoLiDlr, apMoLiDlr);
//                        leadList.sort((Lsh导入名单Model m1, Lsh导入名单Model m2) -> m2.get线索创建日期().compareTo(m1.get线索创建日期()));
//                        for (int i = 0 ; i < leadList.size(); i++) {
//                            if (i == 0) {
//                                lsh导入名单Repository.updateCodeTelSexByCode(re.活动编号, re.顾客姓名, sex, leadList.get(i).get导入编号());
//                                // 更新导入名单附属表，更新导入名单联系表
//                                saveLshImportOthers(leadList.get(i).get导入编号(), dealer, user, leadList.get(i).get活动编号(), re.活动编号);
//                            }
//                        }
                    } else { // 有数据，但既无名单，也无线索，新增数据
                        insertList1.add(re);
                    }
                } else { // 存在于顾客记录汇总
                    // 先处理相关名单
                    List<Lsh导入名单Model> nameLi = imMoLiDlr.stream().filter(i -> i.get电话号码().equals(re.电话号码)
                            && "否".equals(i.get是否线索()) && "是".equals(i.get是否有效线索())).collect(Collectors.toList());
                    for (Lsh导入名单Model mo : nameLi) {
                        mo.set是否有效线索("否");
                    }
                    // 再处理相关线索
                    // case2.1 导入数据存在于系统中，且顾客未进店（顾客进店记录表中没有记录，导入名单表中 是否线索=是 是否有效线索=是）
                    顾客记录汇总Model cusMo = cusMoOp.get(); // 拿到顾客记录汇总
                    // 根据顾客编号在本店的进店记录中将此人进店记录过滤出来
                    List<顾客进店记录表Model> curInList = cusInMoLiDlr.stream().filter(i -> cusMo.get顾客编号().equals(i.get顾客编号())).collect(Collectors.toList());
                    if (curInList == null || curInList.size() == 0) { // 如果未进店
//                        // 寻找3个月内的有效线索（3个月指自然月，即当天到当月第1天，并且往前推2个月，比如20170417，3个月内指20170201~20170417）
//                        LocalDate beginDate = LocalDate.now().minusMonths(2).withDayOfMonth(1); // 前3个自然月的开始
//                        List<Lsh导入名单Model> tmp = imMoList.stream().filter(
//                                i -> "是".equals(i.get是否线索()) && "是".equals(i.get是否有效线索())
//                                        && beginDate.minusDays(1).isBefore(i.get线索创建日期().toLocalDate())
//                                        && i.get线索创建日期().toLocalDate().isBefore(LocalDate.now().plusDays(1)))
//                                .collect(Collectors.toList());
//                        if (tmp == null || tmp.size() == 0) { // 如果不存在则新增
//                            insertList2.add(re);
//                        } else { // 存在则更新最新的一条
//                            tmp.sort((Lsh导入名单Model m1, Lsh导入名单Model m2) -> m2.get线索创建日期().compareTo(m1.get线索创建日期()));
//                            for (int i = 0; i < tmp.size(); i++) {
//                                if (i == 0) {
//                                    lsh导入名单Repository.updateCodeTelSexByCode(re.活动编号, re.顾客姓名, sex, tmp.get(i).get导入编号());
//                                    saveLshImportOthers(tmp.get(i).get导入编号(), dealer, user, tmp.get(i).get活动编号(), re.活动编号);
//                                }
//                            }
//                        }
                        threeMonthProcess(imMoList, insertList2, re, sex, dealer, user, imLi, imReqLi,
                                sycConLi, sycApLi, apLi, deApLi, conMoLiDlr, apMoLiDlr);
                    } else { // case2.2 导入数据存在于系统中，且进过店
                        顾客记录汇总Model mo = cusMoOp.get();
                        String cusStatus = mo.get顾客状态();
                        if ("本月".equals(cusStatus) || "活跃".equals(cusStatus) || "休眠".equals(cusStatus)) {
//                            // 寻找3个月内的有效线索（3个月指自然月，即当天到当月第1天，并且往前推2个月，比如20170417，3个月内指20170201~20170417）
//                            LocalDate beginDate = LocalDate.now().minusMonths(2).withDayOfMonth(1); // 前3个自然月的开始
//                            List<Lsh导入名单Model> tmp = imMoList.stream().filter(
//                                    i -> "是".equals(i.get是否线索()) && "是".equals(i.get是否有效线索())
//                                            && beginDate.minusDays(1).isBefore(i.get线索创建日期().toLocalDate())
//                                            && i.get线索创建日期().toLocalDate().isBefore(LocalDate.now().plusDays(1)))
//                                    .collect(Collectors.toList());
//                            if (tmp == null || tmp.size() == 0) { // 如果不存在则新增
//                                insertList3.add(re);
//                            } else { // 存在则更新最新的一条
//                                tmp.sort((Lsh导入名单Model m1, Lsh导入名单Model m2) -> m2.get线索创建日期().compareTo(m1.get线索创建日期()));
//                                for (int i = 0; i < tmp.size(); i++) {
//                                    if (i == 0) {
//                                        lsh导入名单Repository.updateCodeTelSexByCode(re.活动编号, re.顾客姓名, sex, tmp.get(i).get导入编号());
//                                        saveLshImportOthers(tmp.get(i).get导入编号(), dealer, user, tmp.get(i).get活动编号(), re.活动编号);
//                                    }
//                                }
//                            }
                            threeMonthProcess(imMoList, insertList3, re, sex, dealer, user, imLi, imReqLi,
                                    sycConLi, sycApLi, apLi, deApLi, conMoLiDlr, apMoLiDlr);
                        } else {
                            // 寻找3个月内的有效线索（3个月指自然月，即当天到当月第1天，并且往前推2个月，比如20170417，3个月内指20170201~20170417）
                            LocalDate beginDate = LocalDate.now().minusMonths(2).withDayOfMonth(1); // 前3个自然月的开始
                            List<Lsh导入名单Model> tmp = imMoList.stream().filter(
                                    i -> "是".equals(i.get是否线索()) && "是".equals(i.get是否有效线索())
                                            && beginDate.minusDays(1).isBefore(i.get线索创建日期().toLocalDate())
                                            && i.get线索创建日期().toLocalDate().isBefore(LocalDate.now().plusDays(1)))
                                    .collect(Collectors.toList());
                            if (tmp == null || tmp.size() == 0) { // 如果不存在则新增
                                insertList2.add(re);
                            } else { // 存在，取最新的一条，比较 线索创建日期 与 该线索在顾客进店表中最新的进店日期
                                tmp.sort((Lsh导入名单Model m1, Lsh导入名单Model m2) -> m2.get线索创建日期().compareTo(m1.get线索创建日期()));
                                Lsh导入名单Model last = tmp.get(0);
                                java.sql.Date leadDate = last.get线索创建日期();
                                curInList.sort((顾客进店记录表Model i1, 顾客进店记录表Model i2) -> i2.get进店日期().compareTo(i1.get进店日期()));
                                java.sql.Date inDate = curInList.get(0).get进店日期();
                                if (inDate.before(leadDate)) { // 如果进店日期 < 线索创建日期
                                    updateLast(tmp, re, sex, dealer, user, imLi, imReqLi, sycConLi, sycApLi, apLi, deApLi, conMoLiDlr, apMoLiDlr);
                                } else {
                                    insertList2.add(re);
                                }
//                                for (int i = 0; i < tmp.size(); i++) {
//                                    if (i == 0) {
//                                        lsh导入名单Repository.updateCodeTelSexByCode(re.活动编号, re.顾客姓名, sex, tmp.get(i).get导入编号());
//                                        saveLshImportOthers(tmp.get(i).get导入编号(), dealer, user, tmp.get(i).get活动编号(), re.活动编号);
//                                    }
//                                }
                            }
//                            threeMonthProcess(imMoList, insertList2, re, sex, dealer, user, imLi, imReqLi,
//                                    sycConLi, sycApLi, apLi, deApLi, conMoLiDlr, apMoLiDlr);
                        }
                    }
                }
            }
            ResultData resultData = threeCasesFromReToIm(iniNum, dealer, user, maSetMoLiDlr, imMoLiDlr, userMoLiDlr,
                    cusMoLiDlr, insertList1, insertList2, insertList3, reList, reReqLi);
            if ("false".equals(resultData.getResult())) {
                errMsg = resultData.getMessage();
                throw new Exception();
            }
            List<Lsh导入名单Model> toInsertList = resultData.getPageData().getData();
            lsh导入名单Repository.save(toInsertList);
            // 处理Lsh导入名单联系表
            List<Lsh导入名单联系表Model> conMoList = new ArrayList<>(iniNum);
            for (Lsh导入名单Model mo : toInsertList) {
                Lsh导入名单联系表Model conMo = new Lsh导入名单联系表Model();
                conMo.set许可(dealer);
                conMo.set导入编号(mo.get导入编号());
                conMo.set更新账号(user);
                conMo.set更新时间(Timestamp.valueOf(LocalDateTime.now()));
                conMoList.add(conMo);
            }
            lsh导入名单联系表Repository.save(conMoList);
            // 处理Lsh导入名单联系附属
            List<Lsh导入名单联系附属Model> apMoList = new ArrayList<>(iniNum);
            for (Lsh导入名单联系表Model mo : conMoList) {
                Lsh导入名单联系附属Model apMo = new Lsh导入名单联系附属Model();
                apMo.set联系记录编号(mo.get联系记录编号());
                apMo.set活动编号(toInsertList.get(0).get活动编号()); // 所有活动编号都一样
                apMoList.add(apMo);
            }
            lsh导入名单联系附属Repository.save(apMoList);
            // imLi
            lsh导入名单Repository.save(imLi);
            // sycConLi sycApLi 同步更新
            lsh导入名单联系表Repository.save(sycConLi);
            for (int i = 0; i < sycApLi.size(); i++) {
                Lsh导入名单联系附属Model apMo = sycApLi.get(i);
                apMo.set联系记录编号(sycConLi.get(i).get联系记录编号());
            }
            lsh导入名单联系附属Repository.save(sycApLi);
            // deApLi apLi
            lsh导入名单联系附属Repository.delete(deApLi);
            lsh导入名单联系附属Repository.save(apLi);
            // 待办事项处理
            List<Lsh待办事项Model> toDoLi = new ArrayList<>(iniNum);
            for (int i = 0; i < reList.size(); i++) {
                Lsh导入名单Model mo = reList.get(i);
                String sc = mo.get所属销售顾问();
                if (sc != null) { // 销售顾问不为空时
//                    List<Lsh待办事项Model> toDoList = toDoMoLiDlr.stream().filter(i -> "线索".equals(i.get附属编号类型()) && mo.get导入编号().equals(i.get附属编号()) && "预约接待".equals(i.get待办分类())).collect(Collectors.toList());
                    // 对于reList来说，全部是新增
                    createToDoMo(dealer, user, reReqLi, toDoLi, i, mo);
                } // 为空时不操作
            }
            for (int i = 0; i < imLi.size(); i++) {
                Lsh导入名单Model mo = imLi.get(i);
                String sc = mo.get所属销售顾问();
                if (sc != null) {
                    List<Lsh待办事项Model> toDoList = toDoMoLiDlr.stream().filter(j -> "线索".equals(j.get附属编号类型())
                            && mo.get导入编号().equals(j.get附属编号()) && "预约接待".equals(j.get待办分类())).collect(Collectors.toList());
                    if (toDoList != null && toDoList.size() != 0) { // 有数据时更新
                        for (Lsh待办事项Model toDoMo : toDoList) {
                            toDoMo.set开始时间(Timestamp.valueOf(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(imReqLi.get(i).活动开始日期)));
                            toDoMo.set结束时间(Timestamp.valueOf(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(imReqLi.get(i).活动结束日期)));
                            toDoLi.add(toDoMo);
                        }
                    } else { // 无数据时新增
                        createToDoMo(dealer, user, imReqLi, toDoLi, i, mo);
                    }
                } // 为空时不操作
            }
            lsh待办事项Repository.save(toDoLi);
            return new ResultData("true", null, null);
        } catch (Exception e) {
            logger.error(errMsg, e);
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return new ResultData("false", errMsg, null);
        }
    }

    /**
     * 创建新的待办事项
     *
     * @param dealer  许可
     * @param user    用户
     * @param reReqLi 同步日期的请求List
     * @param toDoLi  准备保存的数据
     * @param i       循环变量
     * @param mo      待处理的导入名单
     */
    private void createToDoMo(String dealer, String user, List<SaveActivityInviteRequest> reReqLi,
                              List<Lsh待办事项Model> toDoLi, int i, Lsh导入名单Model mo) {
        Lsh待办事项Model toDoMo = new Lsh待办事项Model();
        toDoMo.set许可(dealer);
        toDoMo.set销售顾问(mo.get所属销售顾问());
        toDoMo.set开始时间(Timestamp.valueOf(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(reReqLi.get(i).活动开始日期)));
        toDoMo.set结束时间(Timestamp.valueOf(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(reReqLi.get(i).活动结束日期)));
        toDoMo.set内容("预约接待 推送预约到店 " + mo.get顾客姓名());
        toDoMo.set附属编号(mo.get导入编号());
        toDoMo.set是否删除("否");
        toDoMo.set更新账号(user);
        toDoMo.set待办分类("预约接待");
        toDoMo.set附属编号类型("线索");
        toDoMo.set更新时间(Timestamp.valueOf(LocalDateTime.now()));
        toDoLi.add(toDoMo);
    }

    /**
     * 三个月逻辑的判断与处理
     *
     * @param imMoList     源导入名单记录
     * @param toInsertList 待插入的数据列表
     * @param re           前台传入的各参数
     * @param sex          处理后的名单性别
     * @param dlr          许可
     * @param user         用户
     * @param imLi         待更新的lsh导入名单数据
     * @param imReqLi      与imLi同步的请求List
     * @param sycConLi     同步的联系表待处理数据
     * @param sycApLi      同步的附属表待处理数据
     * @param apLi         待新增的附属数据
     * @param deApLi       待删除的附属数据，apLi新增前删除
     * @param conMoLiDlr   本许可下的联系表数据
     * @param apMoLiDlr    本许可下的附属数据
     */
    private void threeMonthProcess(List<Lsh导入名单Model> imMoList, List<SaveActivityInviteRequest> toInsertList,
                                   SaveActivityInviteRequest re, String sex, String dlr, String user,
                                   List<Lsh导入名单Model> imLi, List<SaveActivityInviteRequest> imReqLi,
                                   List<Lsh导入名单联系表Model> sycConLi, List<Lsh导入名单联系附属Model> sycApLi,
                                   List<Lsh导入名单联系附属Model> apLi, List<Lsh导入名单联系附属Model> deApLi,
                                   List<Lsh导入名单联系表Model> conMoLiDlr, List<Lsh导入名单联系附属Model> apMoLiDlr) {
        // 寻找3个月内的有效线索（3个月指自然月，即当天到当月第1天，并且往前推2个月，比如20170417，3个月内指20170201~20170417）
        LocalDate beginDate = LocalDate.now().minusMonths(2).withDayOfMonth(1); // 前3个自然月的开始
        List<Lsh导入名单Model> tmp = imMoList.stream().filter(
                i -> "是".equals(i.get是否线索()) && "是".equals(i.get是否有效线索())
                        && beginDate.minusDays(1).isBefore(i.get线索创建日期().toLocalDate())
                        && i.get线索创建日期().toLocalDate().isBefore(LocalDate.now().plusDays(1)))
                .collect(Collectors.toList());
        if (tmp == null || tmp.size() == 0) { // 如果不存在则新增
            toInsertList.add(re);
        } else { // 存在则更新最新的一条
//            tmp.sort((Lsh导入名单Model m1, Lsh导入名单Model m2) -> m2.get线索创建日期().compareTo(m1.get线索创建日期()));
//            lsh导入名单Repository.updateCodeTelSexByCode(re.活动编号, re.顾客姓名, sex, tmp.get(0).get导入编号());
//            saveLshImportOthers(tmp.get(0).get导入编号(), dealer, user, tmp.get(0).get活动编号(), re.活动编号,
//                    sycConLi, sycApLi, apLi, deApLi, conMoLiDlr, apMoLiDlr);
            updateLast(tmp, re, sex, dlr, user, imLi, imReqLi, sycConLi, sycApLi, apLi, deApLi, conMoLiDlr, apMoLiDlr);
        }
    }

    /**
     * 根据要求处理最新的一条数据
     *
     * @param imList     源导入名单记录
     * @param re         前台传入的各参数
     * @param sex        处理后的名单性别
     * @param dlr        许可
     * @param user       用户
     * @param imLi       待更新的lsh导入名单数据
     * @param imReqLi    与imLi同步的请求List
     * @param sycConLi   同步的联系表待处理数据
     * @param sycApLi    同步的附属表待处理数据
     * @param apLi       待新增的附属数据
     * @param deApLi     待删除的附属数据，apLi新增前删除
     * @param conMoLiDlr 本许可下的联系表数据
     * @param apMoLiDlr  本许可下的附属数据
     */
    private void updateLast(List<Lsh导入名单Model> imList, SaveActivityInviteRequest re, String sex, String dlr, String user,
                            List<Lsh导入名单Model> imLi, List<SaveActivityInviteRequest> imReqLi,
                            List<Lsh导入名单联系表Model> sycConLi, List<Lsh导入名单联系附属Model> sycApLi,
                            List<Lsh导入名单联系附属Model> apLi, List<Lsh导入名单联系附属Model> deApLi,
                            List<Lsh导入名单联系表Model> conMoLiDlr, List<Lsh导入名单联系附属Model> apMoLiDlr) {
        imList.sort((Lsh导入名单Model m1, Lsh导入名单Model m2) -> m2.get线索创建日期().compareTo(m1.get线索创建日期()));
        Integer oldActNum = imList.get(0).get活动编号();
        Lsh导入名单Model mo = imList.get(0);
        mo.set导入状态(0);
        mo.set活动编号(re.活动编号);
        mo.set顾客姓名(re.顾客姓名);
        mo.set顾客性别(sex);
        mo.set线索创建日期(java.sql.Date.valueOf(LocalDate.now()));
        imLi.add(mo);
        imReqLi.add(re);
        saveLshImportOthers(mo.get导入编号(), dlr, user, oldActNum, re.活动编号, sycConLi, sycApLi, apLi, deApLi, conMoLiDlr, apMoLiDlr);
    }

    /**
     * 按要求处理联系表及附属表数据
     *
     * @param toModifyImNum 待修改的导入编号
     * @param dlr           许可
     * @param user          修改人
     * @param oldActNum     旧活动编号
     * @param newActNum     新活动编号
     * @param sycConLi      同步的联系表待处理数据
     * @param sycApLi       同步的附属表待处理数据
     * @param apLi          待新增的附属数据
     * @param deApLi        待删除的附属数据，apLi新增前删除
     * @param conMoLiDlr    本许可下的联系表数据
     * @param apMoLiDlr     本许可下的附属数据
     */
    private void saveLshImportOthers(Integer toModifyImNum, String dlr, String user, Integer oldActNum, Integer newActNum,
                                     List<Lsh导入名单联系表Model> sycConLi, List<Lsh导入名单联系附属Model> sycApLi,
                                     List<Lsh导入名单联系附属Model> apLi, List<Lsh导入名单联系附属Model> deApLi,
                                     List<Lsh导入名单联系表Model> conMoLiDlr, List<Lsh导入名单联系附属Model> apMoLiDlr) {
        // 根据许可与导入编号，应该只能找到至多一条数据
//        Lsh导入名单联系表Model imContact = lsh导入名单联系表Repository.findByImportIdAndPermit(toModifyImNum, dealer);
        Optional<Lsh导入名单联系表Model> imContactOp = conMoLiDlr.stream().filter(i -> i.get导入编号().equals(toModifyImNum)).findFirst();
        if (!imContactOp.isPresent()) { // 找不到，添加新数据
            // 添加LSH导入名单联系表
            Lsh导入名单联系表Model imConMo = new Lsh导入名单联系表Model();
            imConMo.set许可(dlr);
            imConMo.set导入编号(toModifyImNum);
            imConMo.set更新账号(user);
            imConMo.set更新时间(Timestamp.valueOf(LocalDateTime.now()));
//            Lsh导入名单联系表Model tmp = lsh导入名单联系表Repository.save(imConMo);
            sycConLi.add(imConMo);
            // 添加LSH导入名单联系附属
            Lsh导入名单联系附属Model imConApMo = new Lsh导入名单联系附属Model();
//            imConApMo.set联系记录编号(tmp.get联系记录编号());
            imConApMo.set活动编号(newActNum);
//            lsh导入名单联系附属Repository.save(imConApMo);
            sycApLi.add(imConApMo);
        } else { // 找到，更新
            // 这里可能有多条数据
//            List<Lsh导入名单联系附属Model> imConApList = lsh导入名单联系附属Repository.findBy联系记录编号(imContact.get联系记录编号());
            List<Lsh导入名单联系附属Model> imConApList = apMoLiDlr.stream()
                    .filter(i -> i.get联系记录编号().equals(imContactOp.get().get联系记录编号())).collect(Collectors.toList());
            // 附属表中，如果活动编号与刚刚更新的线索活动编号相同，将其更新为传入的活动编号
//            imConApList.stream().filter(i -> i.get活动编号().equals(oldActNum)).forEach(i -> i.set活动编号(newActNum)); // key更新，会失败
            for (Lsh导入名单联系附属Model mo : imConApList) { // 先删除原记录，再新建
                if (mo.get活动编号().equals(oldActNum)) {
                    Lsh导入名单联系附属Model newMo = new Lsh导入名单联系附属Model();
                    newMo.set联系记录编号(mo.get联系记录编号());
                    newMo.set活动编号(newActNum);
//                    lsh导入名单联系附属Repository.delete(mo);
//                    lsh导入名单联系附属Repository.save(newMo);
                    deApLi.add(mo);
                    apLi.add(newMo);
                }
            }
        }
    }

    /**
     * 按要求将请求的request数据，转化成三种不同分类的待新增Model
     *
     * @param iniNum       数组初始化参数
     * @param dealer       许可
     * @param user         用户
     * @param maSetMoLiDlr 许可内的市场设置记录
     * @param imMoLiDlr    许可内的导入名单
     * @param userMoLiDlr  许可内的用户
     * @param cusMoLiDlr   许可下的顾客记录汇总
     * @param insertList1  待新增列表
     * @param insertList2  待新增列表
     * @param insertList3  待新增列表
     * @param reList       insertList2 insertList3 的合集
     * @param reReqList    与reList同步的请求列表
     * @return 标准返回
     */
    private ResultData threeCasesFromReToIm(Integer iniNum, String dealer, String user,
                                            List<Lsh市场设置Model> maSetMoLiDlr,
                                            List<Lsh导入名单Model> imMoLiDlr,
                                            List<用户Model> userMoLiDlr,
                                            List<顾客记录汇总Model> cusMoLiDlr,
                                            List<SaveActivityInviteRequest> insertList1,
                                            List<SaveActivityInviteRequest> insertList2,
                                            List<SaveActivityInviteRequest> insertList3,
                                            List<Lsh导入名单Model> reList,
                                            List<SaveActivityInviteRequest> reReqList) {
        String errMsg = "threeCasesFromReToIm方法异常";
        try {
            List<Lsh导入名单Model> toInsertList = new ArrayList<>(iniNum);
            // insertList1 是否线索 = 否，是否有效线索 = 是，渠道 = “主动集客”，关联活动，意向车型 = null
            for (SaveActivityInviteRequest re : insertList1) {
                Lsh导入名单Model mo = new Lsh导入名单Model();
                mo.set活动编号(re.活动编号);
                mo.set许可(dealer);
                mo.set顾客姓名(re.顾客姓名);
                mo.set电话号码(re.电话号码);
                mo.set顾客性别(re.顾客性别.trim().length() == 0 ? "男" : re.顾客性别);
                mo.set渠道("主动集客");
                mo.set来源(re.市场来源);
                List<Lsh市场设置Model> tmp;
                if (re.来源分类 == null) {
                    tmp = maSetMoLiDlr.stream().filter(i -> "主动集客".equals(i.get渠道())
                            && re.市场来源.equals(i.get来源())).collect(Collectors.toList());
                } else {
                    tmp = maSetMoLiDlr.stream().filter(i -> "主动集客".equals(i.get渠道())
                            && re.来源分类.equals(i.get来源分类()) && re.市场来源.equals(i.get来源())).collect(Collectors.toList());
                }
                if (tmp != null && tmp.size() != 0) {
                    mo.set市场编号(tmp.get(0).get市场编号());
                } else {
                    mo.set市场编号(null);
                }
                mo.set车型编号(null);
                mo.set保有品牌(null);
                mo.set保有月数(null);
                mo.set预计购车日期(null);
                mo.set客户级别(null);
//                mo.set是否同行(null);
//                mo.set同行人数(null);
                mo.set是否试驾(null);
                mo.set是否评估(null);
                mo.set是否置换(null);
                mo.set是否金融(null);
                mo.set是否线索("否");
                mo.set是否有效线索("是");
                mo.set备注(null);
                mo.set导入日期(java.sql.Date.valueOf(LocalDate.now()));
                mo.set所属CDO(null);
                mo.set所属销售顾问(null);
                mo.set下次跟进日期(null);
                mo.set线索创建日期(java.sql.Date.valueOf(LocalDate.now()));
                mo.set预约编号(null);
//                mo.set顾客编号(null);
                mo.set推荐人顾客编号(null);
                mo.set战败去向(null);
                mo.set战败去向备注(null);
                mo.set新车销售状态(null);
                mo.set导入状态(0);
                mo.set更新账号(user);
                mo.set更新时间(Timestamp.valueOf(LocalDateTime.now()));
                toInsertList.add(mo);
            }
            // insertList2 是否线索 = 是，是否有效线索 = 是，渠道 = 主动集客，CDO = 最近CDO，车型 = null
            for (SaveActivityInviteRequest re : insertList2) {
                Lsh导入名单Model mo = new Lsh导入名单Model();
                mo.set活动编号(re.活动编号);
                mo.set许可(dealer);
                mo.set顾客姓名(re.顾客姓名);
                mo.set电话号码(re.电话号码);
                mo.set顾客性别(re.顾客性别.trim().length() == 0 ? "男" : re.顾客性别);
                mo.set渠道("主动集客");
                mo.set来源(re.市场来源);
                List<Lsh市场设置Model> tmp;
                if (re.来源分类 == null) {
                    tmp = maSetMoLiDlr.stream().filter(i -> "主动集客".equals(i.get渠道())
                            && re.市场来源.equals(i.get来源())).collect(Collectors.toList());
                } else {
                    tmp = maSetMoLiDlr.stream().filter(i -> "主动集客".equals(i.get渠道())
                            && re.来源分类.equals(i.get来源分类()) && re.市场来源.equals(i.get来源())).collect(Collectors.toList());
                }
                if (tmp != null && tmp.size() != 0) {
                    mo.set市场编号(tmp.get(0).get市场编号());
                } else {
                    mo.set市场编号(null);
                }
                mo.set车型编号(null);
                mo.set保有品牌(null);
                mo.set保有月数(null);
                mo.set预计购车日期(null);
                mo.set客户级别(re.客户级别);
//                mo.set是否同行(null);
//                mo.set同行人数(null);
                mo.set是否试驾(null);
                mo.set是否评估(null);
                mo.set是否置换(null);
                mo.set是否金融(null);
                mo.set是否线索("是");
                mo.set是否有效线索("是");
                mo.set备注(null);
                mo.set导入日期(java.sql.Date.valueOf(LocalDate.now()));
                List<Lsh导入名单Model> tmp2 = imMoLiDlr.stream().filter(
                        i -> re.电话号码.equals(i.get电话号码()) && i.get所属CDO() != null).collect(Collectors.toList());
                if (tmp2 != null && tmp2.size() != 0) {
                    tmp2.sort((m1, m2) -> m2.get线索创建日期().compareTo(m1.get线索创建日期())); // 排序
                    mo.set所属CDO(tmp2.get(0).get所属CDO()); // 拿新最的CDO
                } else {
                    mo.set所属CDO(null);
                }
                List<用户Model> scList = userMoLiDlr.stream().filter(i -> i.get人员姓名().equals(re.所属销售顾问)).collect(Collectors.toList());
                if (scList == null || scList.size() == 0) {
                    mo.set所属销售顾问(null);
                } else {
                    mo.set所属销售顾问(scList.get(0).get用户名());
                }
                mo.set下次跟进日期(null);
                mo.set线索创建日期(java.sql.Date.valueOf(LocalDate.now()));
                mo.set预约编号(null);
//                mo.set顾客编号(null);
                mo.set推荐人顾客编号(null);
                mo.set战败去向(null);
                mo.set战败去向备注(null);
                mo.set新车销售状态(null);
                mo.set导入状态(0);
                mo.set更新账号(user);
                mo.set更新时间(Timestamp.valueOf(LocalDateTime.now()));
                toInsertList.add(mo);
                reList.add(mo);
                reReqList.add(re);
            }
            // 是否线索 = 是，是否有效线索 = 是，将顾客记录汇总中的字段(渠道，顾客级别，销售顾问等)，刷新到re再添加到insertListIn，车型 = null
            for (SaveActivityInviteRequest re : insertList3) {
                List<顾客记录汇总Model> cusMoList = cusMoLiDlr.stream().filter(
                        i -> re.电话号码.equals(i.get电话号码())).collect(Collectors.toList()); // 必定能找到一条
                if (cusMoList == null || cusMoList.size() == 0) {
                    errMsg = "线索" + re.电话号码 + "不存在于顾客记录汇总";
                    throw new Exception();
                }
                顾客记录汇总Model cusMo = cusMoList.get(0);
                Lsh导入名单Model mo = new Lsh导入名单Model();
                mo.set活动编号(re.活动编号);
                mo.set许可(dealer);
                mo.set顾客姓名(re.顾客姓名);
                mo.set电话号码(cusMo.get电话号码());
                mo.set顾客性别(cusMo.get顾客性别());
                mo.set渠道(cusMo.get顾客渠道());
                mo.set来源(cusMo.get顾客来源());
                List<Lsh市场设置Model> tmp;
                if (re.来源分类 == null) {
                    tmp = maSetMoLiDlr.stream().filter(i -> "主动集客".equals(i.get渠道())
                            && re.市场来源.equals(i.get来源())).collect(Collectors.toList());
                } else {
                    tmp = maSetMoLiDlr.stream().filter(i -> "主动集客".equals(i.get渠道())
                            && re.来源分类.equals(i.get来源分类()) && re.市场来源.equals(i.get来源())).collect(Collectors.toList());
                }
                if (tmp != null && tmp.size() != 0) {
                    mo.set市场编号(tmp.get(0).get市场编号());
                } else {
                    mo.set市场编号(null);
                }
                mo.set车型编号(null);
                mo.set保有品牌(null);
                mo.set保有月数(null);
                mo.set预计购车日期(null);
                mo.set客户级别(cusMo.get新顾客级别());
//                mo.set是否同行(null);
//                mo.set同行人数(null);
                mo.set是否试驾(null);
                mo.set是否评估(null);
                mo.set是否置换(null);
                mo.set是否金融(null);
                mo.set是否线索("是");
                mo.set是否有效线索("是");
                mo.set备注(null);
                mo.set导入日期(java.sql.Date.valueOf(LocalDate.now()));
                mo.set所属CDO(null);
                mo.set所属销售顾问(cusMo.get所属销售顾问());
                mo.set下次跟进日期(null);
                mo.set线索创建日期(java.sql.Date.valueOf(LocalDate.now()));
                mo.set预约编号(null);
//                mo.set顾客编号(null);
                mo.set推荐人顾客编号(null);
                mo.set战败去向(null);
                mo.set战败去向备注(null);
                mo.set新车销售状态(null);
                mo.set导入状态(0);
                mo.set更新账号(user);
                mo.set更新时间(Timestamp.valueOf(LocalDateTime.now()));
                toInsertList.add(mo);
                reList.add(mo);
                reReqList.add(re);
            }
            return new ResultData("true", null, new PageData(toInsertList, toInsertList.size()));
        } catch (Exception e) {
            logger.warn(errMsg, e);
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return new ResultData("false", errMsg, null);
        }
    }

//    private Lsh导入名单Model doNotInImportRecords(SaveActivityInviteRequest s, Date dtTime, Lsh导入名单Model m, List list,
//                                              顾客记录汇总Model n) {
//        List<Lsh导入名单Model> listOld = lsh导入名单Repository.findByPhoneAndPermitAndTimeDesc(s.电话号码, s.许可, dtTime);
//        if (listOld.size() > 0) {
//            //有效，三个月内，sc/cdo保留
//            Lsh导入名单Model lm = getLshImportRec(s);
//            if (m != null) {
//                lm.set所属CDO(m.get所属CDO());
//                lm.set所属销售顾问(m.get所属销售顾问());
//                lm.set渠道(m.get渠道());
//                lm.set来源(m.get来源());
//                lm.set市场编号(m.get市场编号());
//                lm.set客户级别(m.get客户级别());
//            } else {
//                List<Lsh市场设置Model> list市场设置 = lsh市场设置Repository.findBy许可And渠道And来源(s.许可, s.渠道, s.来源);
//                if (list市场设置.size() > 0) {
//                    lm.set市场编号(list市场设置.get(0).get市场编号());
//                }
//                lm.set所属销售顾问(n.get所属销售顾问());
//                lm.set渠道(n.get顾客渠道());
//                lm.set来源(n.get顾客来源());
//                lm.set客户级别(n.get新顾客级别());
//            }
//
//            Lsh导入名单Model n3 = lsh导入名单Repository.save(lm);
//            saveLshImporOthers(s.许可, s.更新账号, n3.get导入编号(), s.活动编号);
//            list.add(n3);
//            return n3;
//        } else {
//            //无效，三个月外
//            Lsh导入名单Model lm = getLshImportRec(s);
//            if (m != null) {
//                lm.set所属CDO(m.get所属CDO());
//            }
//            Lsh导入名单Model n4 = lsh导入名单Repository.save(lm);
//            saveLshImporOthers(s.许可, s.更新账号, n4.get导入编号(), s.活动编号);
//            list.add(n4);
//            return n4;
//        }
//    }

    //存入导入名单的同时，需要存入导入名单联系表和附属表
    private void saveLshImporOthers(String permit, String updateUser, Integer importId, Integer actNo) {
        Timestamp ts = DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date());
        //新增联系表
        Lsh导入名单联系表Model contModel = new Lsh导入名单联系表Model();
        contModel.set更新时间(ts);
        contModel.set更新账号(updateUser);
        contModel.set许可(permit);
        contModel.set导入编号(importId);
        Lsh导入名单联系表Model newContModel = lsh导入名单联系表Repository.save(contModel);

        //新增附属表
        Lsh导入名单联系附属Model model附属 = new Lsh导入名单联系附属Model();
        model附属.set活动编号(actNo);
        model附属.set联系记录编号(newContModel.get联系记录编号());
        lsh导入名单联系附属Repository.save(model附属);
    }

    private Lsh导入名单Model getLshImportRec(SaveActivityInviteRequest s) {
        Timestamp timestamp = DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date());
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Calendar c = Calendar.getInstance();
        c.add(Calendar.MONTH, -2);
        Date dtTime = getFormatDate("yyyy-MM-01", c.getTime());//3个自然月前

        Lsh导入名单Model l = new Lsh导入名单Model();
        List<Lsh导入名单Model> list导入名单Model = lsh导入名单Repository.findByPhoneAndPermitAndTimeDesc(s.电话号码, s.许可, dtTime);
        if (list导入名单Model.size() > 0) {
            l.set是否有效线索("否");
        } else {
            l.set是否有效线索("是");
        }
        //获取车型编号
//        if (s.级别 != null) {
//            List<Lsh车型Model> list车型 = lsh车型Repository.findBy来源And品牌And级别(s.来源, s.品牌, s.级别);
//            if (list车型.size() > 0) {
//                l.set车型编号(list车型.get(0).get车型编号());
//            }
//        } else {
//            List<Lsh车型Model> list车型表 = lsh车型Repository.findBy来源And品牌(s.来源, s.品牌);
//            if (list车型表.size() > 0) {
//                l.set车型编号(list车型表.get(0).get车型编号());
//            }
//        }
        if (s.来源分类 != null) {
            List<Lsh市场设置Model> list市场设置 = lsh市场设置Repository.getMarketId(s.许可, s.渠道, s.来源分类, s.来源);
            if (list市场设置.size() > 0) {
                l.set市场编号(list市场设置.get(0).get市场编号());
            }
        } else {
            List<Lsh市场设置Model> list市场设置表 = lsh市场设置Repository.findBy许可And渠道And来源(s.许可, s.渠道, s.市场来源);
            if (list市场设置表.size() > 0) {
                l.set市场编号(list市场设置表.get(0).get市场编号());
            }
        }
        l.set活动编号(s.活动编号);
        l.set许可(s.许可);
        l.set顾客姓名(s.顾客姓名);
        l.set电话号码(s.电话号码);
        l.set顾客性别(s.顾客性别);
        l.set来源(s.市场来源);
        if ("是".equals(s.是否为新增线索)) {//新增线索 则所属CDO和所属销售顾问列都填null
            l.set所属CDO(null);
            l.set所属销售顾问(null);
        } else {
            l.set所属CDO(s.所属CDO);
            l.set所属销售顾问(s.所属销售顾问);
        }
        if (s.客户级别 == null) {
            l.set客户级别(null);
        } else {
            l.set客户级别(s.客户级别);
        }
        if (s.导入日期 == null) {
            l.set导入日期(java.sql.Date.valueOf(LocalDate.now()));
        } else {
            l.set导入日期(s.导入日期);
        }

        Date d = null;
        //BUG 5159 新增市场活动，保存时，提示保存失败
        try {
            if (!Strings.isNullOrEmpty(s.参加市场活动日期.toString())) {
                d = sdf.parse(s.参加市场活动日期);
                l.set线索创建日期(new java.sql.Date(d.getTime()));
            } else {
                l.set线索创建日期(java.sql.Date.valueOf(LocalDate.now()));
            }
        } catch (Exception e) {
            e.printStackTrace();
            logger.warn("日期转换异常");
        }
        l.set更新时间(timestamp);
        l.set更新账号(s.更新账号);
        l.set渠道("主动集客");
        l.set是否线索("是");
        l.set导入状态(0);
        Lsh导入名单Model newRecords = lsh导入名单Repository.save(l);
        return newRecords;
    }

    /**
     * 校验日期格式
     *
     * @param date
     * @return
     */
    public boolean isDate(String date) {
        String rexp = "^((\\d{2}(([02468][048])|([13579][26]))[\\-\\/\\s]?((((0?[13578])|(1[02]))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|(3[01])))|(((0?[469])|(11))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|(30)))|(0?2[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])))))|(\\d{2}(([02468][1235679])|([13579][01345789]))[\\-\\/\\s]?((((0?[13578])|(1[02]))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|(3[01])))|(((0?[469])|(11))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|(30)))|(0?2[\\-\\/\\s]?((0?[1-9])|(1[0-9])|(2[0-8]))))))";
        Pattern pat = Pattern.compile(rexp);
        Matcher mat = pat.matcher(date);
        boolean dateType = mat.matches();
        return dateType;
    }

    /**
     * 保存活动后邀约名单
     */
    @Override
    @Transactional
    public Map saveActivityAfterInviteList(List<SaveActivityInviteRequest> req) {
        Map result = new HashMap();
        Calendar c = Calendar.getInstance();
        c.setTime(new Date());
        //得到当前年月
        int nowYear = c.get(Calendar.YEAR);
        int nowMonth = c.get(Calendar.MONTH) + 1;

        Timestamp timestamp = DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date());
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        List succList = new ArrayList();
        List failList = new ArrayList();

        List<String> list = new ArrayList<String>();
        List<String> list2 = new ArrayList<String>();

        for (int i = 0; i < req.size(); i++) {
            SaveActivityInviteRequest s = req.get(i);
            Map errorMap = new LinkedHashMap();


            //校验手机号和日期格式
            if (!isMobile(s.电话号码)) {
                errorMap.put("电话", s.电话号码);
                errorMap.put("错误信息", "第" + (i + 1) + "行，电话号码错误");
                failList.add(errorMap);
                continue;
            }

            if (s.参加市场活动日期.length() > 10) {// 如 2017-07-05 12:30:30
                if (!isValidDate(s.参加市场活动日期)) {
                    errorMap.put("电话", s.电话号码);
                    errorMap.put("错误信息", "第" + (i + 1) + "行，日期格式错误");
                    failList.add(errorMap);
                    continue;
                } else {
                    if (s.参加市场活动日期.contains("/")) {
                        sdf = new SimpleDateFormat("yyyy/MM/dd");
                    } else {
                        sdf = new SimpleDateFormat("yyyy-MM-dd");
                    }
                }
            } else {
                if (!isDate(s.参加市场活动日期)) {
                    errorMap.put("电话", s.电话号码);
                    errorMap.put("错误信息", "第" + (i + 1) + "行，日期格式错误");
                    failList.add(errorMap);
                    continue;
                } else {
                    if (s.参加市场活动日期.contains("/")) {
                        sdf = new SimpleDateFormat("yyyy/MM/dd");
                    } else {
                        sdf = new SimpleDateFormat("yyyy-MM-dd");
                    }
                }
            }

            Date sqldate = null;
            try {
                sqldate = sdf.parse(s.参加市场活动日期);
            } catch (Exception e) {
                errorMap.put("电话", s.电话号码);
                errorMap.put("错误信息", "第" + (i + 1) + "行，日期格式错误");
                failList.add(errorMap);
                continue;
            }

            // 需求变更，去掉 不允许导入隔月数据的限制
            /*if (!(nowYear == sqldate.getYear() + 1900 && nowMonth == sqldate.getMonth() + 1)) {
                errorMap.put("电话", s.电话号码);
                errorMap.put("错误信息", "第" + (i + 1) + "行，参加活动日期是上月，无法导入");
                failList.add(errorMap);
                continue;
            }*/

            //判断是否有重复数据 电话号码和日期相同则为相同
            list.add(s.电话号码);
            list2.add(s.参加市场活动日期.toString());
            String temp = "";
            String temp2 = "";
            for (int a = 0; a < list.size() - 1; a++) {
                temp = list.get(a);
                temp2 = list2.get(a);
                for (int j = a + 1; j < list.size(); j++) {
                    if (temp.equals(list.get(j)) && temp2.equals(list2.get(j))) {
                        errorMap.put("电话", s.电话号码);
                        errorMap.put("错误信息", "第" + (a + 1) + "行跟第" + (j + 1) + "行为重复数据");
                        failList.add(errorMap);
                        continue;
                    }
                }
            }

            用户Model model销售 = repository用户.findUserByPermitAnd人员姓名NotDel(s.许可, s.所属销售顾问);
            if (model销售 == null) {
                s.所属销售顾问 = null;
            } else {
                s.所属销售顾问 = model销售.get用户名();
            }

            //查询 顾客记录汇总表 ， s.所属销售顾问
            顾客记录汇总Model old汇总 = repository顾客记录汇总.findCusByPhoneAndPermit(s.电话号码, s.许可);
            c.setTime(new Date());
            c.add(Calendar.MONTH, -2);
            Date startTime = getFormatDate("yyyy-MM-01 hh:mm:ss", c.getTime());//3个自然月前
            Date endTime = getFormatDate("yyyy-MM-dd hh:mm:ss", new Date());
            List<Lsh导入名单Model> 导入名单Model = lsh导入名单Repository.isAvailableClue(s.电话号码, s.许可, startTime, endTime);

            List<Lsh导入名单Model> old导入List = lsh导入名单Repository.findByPhoneAndActivityCodeAndState(s.电话号码, s.活动编号, s.许可);
            //是否展厅
            if (!"是".equals(s.是否展厅)) { // 非展厅
                if (s.所属销售顾问 == null) {//若某客户记录的销售顾问列为空，先判断系统中是否已有所属销售顾问
                    if ((old汇总 != null && old汇总.get所属销售顾问() != null)) {//若有，不做操作

                    } else if (导入名单Model.size() != 0) {

                    } else {//若没有，代表是新增线索，导入后，将分配给CDO。
                        s.是否为新增线索 = "是";
                        Lsh导入名单Model lshImporModel = getLshImportRec(s);
                        lshImporModel.set导入状态(1);
                        lshImporModel = lsh导入名单Repository.save(lshImporModel);
                        //附属表
                        saveLshImporOthers(s.许可, s.更新账号, lshImporModel.get导入编号(), s.活动编号);
                        succList.add(lshImporModel);
                        continue;
                    }
                }

                if (old导入List.size() > 0) {//表示数据库中已有，也算导入成功 (如有销售顾问，更新销售顾问列)
                    lsh导入名单Repository.updSc(s.电话号码, s.活动编号, s.许可, s.所属销售顾问);
                    succList.add(old导入List.get(0));
                } else {
                    // 新增导入名单
                    Lsh导入名单Model lshImporModel = getLshImportRec(s);
                    lshImporModel.set导入状态(1);
                    lshImporModel = lsh导入名单Repository.save(lshImporModel);
                    //附属表
                    saveLshImporOthers(s.许可, s.更新账号, lshImporModel.get导入编号(), s.活动编号);
                    succList.add(lshImporModel);
                }
            } else { // 展厅，写客流日志
                Integer custId;
                if (old汇总 == null) {
                    //顾客记录汇总表没数据，就直接提示无进店记录
                    errorMap.put("电话", s.电话号码);
                    errorMap.put("错误信息", "第" + (i + 1) + "行，无进店记录，无法导入");
                    failList.add(errorMap);
                    continue;
                } else {
                    custId = old汇总.get顾客编号();//拿到顾客编号
                }

                Date joinActDate = null;
                try {
                    joinActDate = sdf.parse(s.参加市场活动日期);
                } catch (Exception e) {
                    logger.warn("日期转换异常");
                }


                //判断 顾客进店记录表 是否进店（当天）
                List<顾客进店记录表Model> model进店记录List = repository顾客进店记录表.findBy顾客编号And许可And进店日期(custId,
                        s.许可, new java.sql.Date(joinActDate.getTime()));
                if (model进店记录List.size() > 0) {//如果有进店记录，进店记录表中要关联这次活动
                    getInroomAct(model进店记录List.get(0).get进店编号(), s.活动编号, s.活动名称);
                } else {//不允许导入该条数据，提示语是“导入成功*条，失败*条。第*行，无进店记录，无法导入。”
                    //无进店记录，添加进店记录，sf规则
                    errorMap.put("电话", s.电话号码);
                    errorMap.put("错误信息", "第" + (i + 1) + "行，无进店记录，无法导入");
                    failList.add(errorMap);
                    continue;
                }

                if (old导入List.size() > 0) {//表示数据库中已有，更新销售顾问列,也算导入成功
                    succList.add(old导入List.get(0));
                } else {
                    //新增导入名单
                    Lsh导入名单Model lshImporModel = getLshImportRec(s);
                    lshImporModel.set导入状态(1);
                    lshImporModel = lsh导入名单Repository.save(lshImporModel);
                    //附属表
                    saveLshImporOthers(s.许可, s.更新账号, lshImporModel.get导入编号(), s.活动编号);
                    succList.add(lshImporModel);
                }
            }

        }
        result.put("succList", succList);
        result.put("succListSize", succList.size());
        result.put("failList", failList);
        result.put("failListSize", failList.size());

        return result;
    }

    //关联活动，新增或修改
    private void getInroomAct(Integer inroomId, Integer actId, String actName) {
        List<InroomActModel> actList = inroomActRepository.findByRoomId(inroomId);
        if (actList.size() > 0) {
            inroomActRepository.updateById(actList.get(0).getId(), actId, actName);
        } else {
            InroomActModel im = new InroomActModel();
            im.setUpdateTime(DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date()));
            im.setActId(actId);
            im.setActName(actName);
            im.setInroomId(inroomId);
            inroomActRepository.save(im);
        }
    }

    @Override
    public List getLshActivitySet() {
        return messageRepository.getLshActivitySet();
    }

    @Override
    @Transactional
    public Map saveLshActivitySet(List<Lsh活动发起设置Model> reqList) {
        Timestamp ts = DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date());
        Map map = Maps.newHashMap();
        int insertCount = 0;
        int updateCount = 0;
        for (int i = 0; i < reqList.size(); i++) {
            Lsh活动发起设置Model m = reqList.get(i);
            if (m.get活动发起编号() == null) {
                m.set更新时间(ts);
                m.set创建时间(ts);
                lsh活动发起设置Repository.save(m);
                insertCount++;
            } else {
                Lsh活动发起设置Model n = lsh活动发起设置Repository.findOne(m.get活动发起编号());
                if (n != null) {
                    m.set创建时间(n.get创建时间());
                    m.set更新时间(ts);
                    lsh活动发起设置Repository.save(m);
                    updateCount++;
                }
            }
        }
        map.put("insertCount", insertCount);
        map.put("updateCount", updateCount);
        return map;
    }

    @Override
    @Transactional
    public boolean updateStatusById(Lsh活动发起设置Model req) {
        try {
            Lsh活动发起设置Model m = lsh活动发起设置Repository.findOne(req.get活动发起编号());
            m.set更新时间(DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date()));
            m.set更新账号(req.get更新账号());
            m.set启用状态(req.get启用状态());
            return true;
        } catch (Exception e) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            logger.error("数据更新异常。", e);
            return false;
        }

    }

    @Override
    public ResultData getClientInfoByTelOverWrite(GetClientInfoByTelOverWrite getClientInfoByTelOverWrite, String permit, String username) {
        ResultData resultData = new ResultData("false", null, null);
        try {
            List list = messageRepository.getClientInfoByTelOverWrite(permit, getClientInfoByTelOverWrite.tel);
            resultData.setResult("true");
            resultData.setPageData(new PageData(list, 1));
        } catch (Exception e) {
            logger.warn(String.format("前台根据顾客电话查询顾客信息失败，许可=%s，电话=%s", permit, getClientInfoByTelOverWrite.tel), e);
            resultData.setMessage("查询失败");
        }
        return resultData;
    }

}
